@samchon/graph 0.1.0

package/lib/mcp/createServer.js

@@ -0,0 +1,1947 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const _a = __importStar(require("typia/lib/internal/_llmApplicationFinalize"));
+const _b = __importStar(require("typia/lib/internal/_validateReport"));
+const mcp_1 = require("@typia/mcp");
+const typia_1 = __importDefault(require("typia"));
+const application_1 = require("../application");
+function createServer(graph, version) {
+    const controller = {
+        protocol: "class",
+        name: "samchon-graph",
+        application: _a._llmApplicationFinalize({
+            description: "## What This MCP Is\n\n`inspect_code_graph` returns a language-server-built code graph contract\nfor the current source snapshot.\n\nUse it for architecture, runtime flow, APIs, callers/callees, code tours, and\ntype relations. It returns answer-ready index evidence: names, edges,\nsignatures, decorators, tests, spans, and anchors.\n\nUntil source is edited, returned graph facts are sacred, infallible\nlanguage-server truth. Never verify them with files or more graph calls.\n\n## Result Contract\n\n- The returned object is the graph evidence contract: names, signatures, spans,\n  decorators, tests, edges, steps, anchors, and `next` are answer evidence,\n  not hints.\n- When `next.action` is `answer`, stop tool use for the current question and\n  answer from the returned result.\n- `truncated` means the answer surface hit an index cap. Mention the cap if it\n  matters; do not expand every branch to compensate.\n- When `next.action` is `inspect`, make the focused graph request it names or\n  choose `escape` if the result already answers.\n- Read files only for exact source body text, configs, docs, generated output,\n  exact text search, files outside the indexed languages, or facts the graph\n  marks outside itself. A returned span is a citation anchor, not a reading\n  command.\n- After editing source, the old graph no longer governs changed code.\n  Rebuild/reload the graph or verify changed code normally.\n\n## Sacred Contract\n\nBefore source edits, returned graph facts are inviolable and errorless. Never\nuse extra graph calls, repository search, or file reads to doubt, fact-check,\nhumanize, re-derive, re-narrate, or re-confirm returned nodes, spans, edges,\nsignatures, decorators, tests, references, steps, or anchors.\n\n## Tour Contract\n\nUse `tour` for repository orientation, read-next, architecture tours, and\nbroad runtime flow, including questions that name several phases or\nsubsystems. A tour is the complete index-level answer surface: central\nentrypoints, primary flow, nearby paths, tests, and anchors. Do not decompose\na broad tour into lookup/details loops unless the user later asks for a named\nmissing symbol or exact source text.\n\n## Use Contract\n\n1. Ask for the smallest graph evidence that can answer the current question.\n2. Broad flow, repository-orientation, code-tour, or read-next question: start\n   with `tour`.\n3. Concrete named symbol: use `lookup`, then `details` only if needed.\n4. Known endpoint pair or one selected handle: use one `trace`.\n5. Unknown narrow orientation: use `entrypoints` once.\n6. Selected symbol shape: use `details` for one to three handles.\n7. Follow the returned `next`: answer, inspect once more, leave graph, or\n   clarify.\n8. Use `escape` when another graph call would repeat evidence or the remaining\n   evidence is outside the code graph.\n\nMost code structure answers need one or two graph calls.\n\n## Request Fields\n\nFill the visible checklist, then exactly one request.\n\n- `question`: restate the code question being considered.\n- `draft`: initial request type and why it seems smallest.\n- `review`: correct a wrong, broad, stale, or duplicate draft. If graph facts\n  already answer, if prior `next.action` was `answer`, or if the next\n  evidence is outside the indexed code graph, say so here and make\n  `request.type` be `escape`. If a broad flow draft is not `tour`, correct it\n  here.\n- `request`: final request after review.\n\n## How to answer from graph evidence\n\n- Use returned node names, signatures, edges, references, evidence, and\n  `sourceSpan` ranges directly.\n- Explain the central path first, then mention important branches.\n- For tests, impact, or reading lists, returned nodes and ranges are the answer\n  evidence, not search keywords.\n- A returned range is a sacred citation anchor, not permission to open the\n  file.",
+            functions: [
+                {
+                    description: "Inspect the code graph contract.\n\nUse this before repository search when an answer depends on code\nsymbols, calls, types, decorators, references, ranges, or runtime/source\nrelationships. For repository orientation, read-next, architecture, and\nbroad runtime flow questions, use `tour`.\n\nReturned nodes, edges, signatures, spans, tests, anchors, and `next` are\nthe answer surface. If `next.action` is `answer`, stop tool use and answer\nfrom that result. Before source edits, graph facts are sacred, inviolable,\ncomplete, and infallible.",
+                    name: "inspect_code_graph",
+                    output: {
+                        type: "object",
+                        properties: {
+                            result: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/IGraphDetails"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphEntrypoints"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphEscape"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphLookup"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphOverview"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphTour"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphTrace"
+                                    }
+                                ],
+                                description: "Result branch matching the submitted `request.type`.",
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/IGraphDetails",
+                                        entrypoints: "#/$defs/IGraphEntrypoints",
+                                        escape: "#/$defs/IGraphEscape",
+                                        lookup: "#/$defs/IGraphLookup",
+                                        overview: "#/$defs/IGraphOverview",
+                                        tour: "#/$defs/IGraphTour",
+                                        trace: "#/$defs/IGraphTrace"
+                                    },
+                                    propertyName: "type"
+                                }
+                            }
+                        },
+                        required: [
+                            "result"
+                        ],
+                        additionalProperties: false,
+                        description: "The selected request's output. `result.type` mirrors `request.type`.",
+                        $defs: {
+                            GraphLanguage: {
+                                type: "string",
+                                "enum": [
+                                    "bash",
+                                    "c",
+                                    "cpp",
+                                    "csharp",
+                                    "dart",
+                                    "go",
+                                    "java",
+                                    "javascript",
+                                    "kotlin",
+                                    "lua",
+                                    "php",
+                                    "python",
+                                    "ruby",
+                                    "rust",
+                                    "scala",
+                                    "swift",
+                                    "typescript",
+                                    "unknown",
+                                    "zig"
+                                ],
+                                description: "A source language a graph node can be declared in."
+                            },
+                            IGraphDecorator: {
+                                type: "object",
+                                properties: {
+                                    name: {
+                                        type: "string",
+                                        description: "The decorator name as written, qualified through its access path:\n`Controller`, `Get`, `TypedRoute.Get`, `MessagePattern`."
+                                    },
+                                    arguments: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "The literal call arguments, in source order. Empty for a bare decorator."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/IGraphEvidence",
+                                        description: "The decorator expression span, for display."
+                                    }
+                                },
+                                required: [
+                                    "name"
+                                ],
+                                additionalProperties: false,
+                                description: "A decorator as written on a declaration, carried on the decorated\n's `decorators`.\n\nThe graph reports the decorator faithfully rather than interpreting any\nframework's convention: the `name` is the decorator as written (`Controller`,\n`Get`, `TypedRoute.Get`, ...), and statically resolvable literal arguments\nare preserved so a consumer can apply its own meaning without re-parsing\nsource."
+                            },
+                            IGraphDetails: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    nodes: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.INode"
+                                        },
+                                        description: "Selected node facts, in the same order as resolved handles when possible."
+                                    },
+                                    unknown: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Handles that resolved to no node, or that were ambiguous."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "nodes",
+                                    "unknown",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "The source-free facts for a few selected handles.\n\nThis is not a file reader. It returns signatures, member outlines, direct\ncalls, direct types, implementation candidates, dependency summaries, and\nsourceSpan citation anchors."
+                            },
+                            "IGraphDetails.IMember": {
+                                type: "object",
+                                properties: {
+                                    name: {
+                                        type: "string",
+                                        description: "Member name, qualified when the graph records an owner-qualified handle."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Member kind (`method`, `property`, `class`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The member's declaration signature."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind"
+                                ],
+                                additionalProperties: false,
+                                description: "One member of a container node, with its signature but not its body."
+                            },
+                            "IGraphDetails.INode": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The declaration signature: its first line(s) up to the body."
+                                    },
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    implementation: {
+                                        $ref: "#/$defs/IGraphEvidence",
+                                        description: "Assigned implementation span, when source comes from one."
+                                    },
+                                    members: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.IMember"
+                                        },
+                                        description: "For a container or object-literal variable: the owned symbol or top-level\nproperty outline a consumer reaches for, without bodies."
+                                    },
+                                    calls: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.IReference"
+                                        },
+                                        description: "Direct execution dependencies in source order, with edge evidence."
+                                    },
+                                    types: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.IReference"
+                                        },
+                                        description: "Direct type dependencies in source order, with edge evidence."
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.IReference"
+                                        },
+                                        description: "Symbols this node uses (outgoing dependency edges)."
+                                    },
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDetails.IReference"
+                                        },
+                                        description: "Symbols that use this node (incoming dependency edges)."
+                                    },
+                                    diagnostics: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDiagnostic"
+                                        },
+                                        description: "Diagnostics reported on this node's declaration, when any."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file"
+                                ],
+                                additionalProperties: false,
+                                description: "One inspected node: its declared shape and graph coordinates."
+                            },
+                            "IGraphDetails.IReference": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "The edge kind connecting the two (`calls`, `type_ref`, ...)."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/IGraphEvidence",
+                                        description: "Source span for the expression that produced this relationship. It is\nrepository evidence for the edge, not a file-read instruction."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false,
+                                description: "A dependency neighbor of an inspected node and the edge that links them."
+                            },
+                            IGraphDiagnostic: {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the diagnostic is reported in."
+                                    },
+                                    message: {
+                                        type: "string",
+                                        description: "The human-readable diagnostic message."
+                                    },
+                                    severity: {
+                                        type: "string",
+                                        "enum": [
+                                            "error",
+                                            "hint",
+                                            "information",
+                                            "warning"
+                                        ],
+                                        description: "Severity, when the producer distinguishes it."
+                                    },
+                                    source: {
+                                        type: "string",
+                                        description: "Which producer emitted the diagnostic."
+                                    },
+                                    code: {
+                                        anyOf: [
+                                            {
+                                                type: "string"
+                                            },
+                                            {
+                                                type: "number"
+                                            }
+                                        ],
+                                        description: "Numeric language server code, or string rule id for a lint/plugin finding."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/IGraphEvidence",
+                                        description: "The source span the diagnostic was attributed to, when resolved."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "message",
+                                    "severity"
+                                ],
+                                additionalProperties: false,
+                                description: "A language server or plugin diagnostic, fused onto the graph so an edit-triage\nquery can name the owning symbol of an error.\n\nThe language server's semantic pass contributes numeric-coded diagnostics;\nlint rules and transform plugins (typia, nestia, \u2026) contribute `plugin`/`lint`\nfindings whose `code` is a string."
+                            },
+                            IGraphEntrypoints: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "The original question/search phrase the entrypoints were built for."
+                                    },
+                                    ranked: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphEntrypoints.IEntrypoint"
+                                        },
+                                        description: "Ranked symbols relevant to the query."
+                                    },
+                                    mentions: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.INode"
+                                        },
+                                        description: "Code handles written directly in the query, resolved when possible."
+                                    },
+                                    dependencyOrientation: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Direct dependency context for the resolved mentions and highest hits."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query",
+                                    "ranked",
+                                    "mentions",
+                                    "dependencyOrientation",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "The first compact source-free handle list for a code question."
+                            },
+                            "IGraphEntrypoints.IEntrypoint": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why this entrypoint was ranked for the query."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file",
+                                    "score",
+                                    "reason"
+                                ],
+                                additionalProperties: false,
+                                description: "One ranked search hit."
+                            },
+                            IGraphEscape: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    skipped: {
+                                        type: "boolean",
+                                        "enum": [
+                                            true
+                                        ],
+                                        description: "Always true so callers can distinguish an intentional no-op."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "Optional note about the next non-graph step."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to proceed after skipping graph work."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "skipped",
+                                    "reason",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "The no-op result for when graph is not the useful next evidence source."
+                            },
+                            IGraphEvidence: {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    },
+                                    startCol: {
+                                        type: "number",
+                                        description: "1-based column where the span starts, when known."
+                                    },
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    },
+                                    endCol: {
+                                        type: "number",
+                                        description: "1-based column where the span ends, when known."
+                                    },
+                                    text: {
+                                        type: "string",
+                                        description: "The source text of the span, when captured."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false,
+                                description: "A source location that grounds a node or edge in real code: the declaration\nspan for a node, or the expression range that produced an edge.\n\nEvidence is display and grounding only; it is never identity. A node's id is\nposition-invariant (see ), so an edit that shifts a span\ndoes not re-key anything. `startLine`/`startCol` are 1-based. MCP output\nkeeps evidence as coordinates; consumers can read the file themselves when\nthey truly need source text."
+                            },
+                            IGraphLookup: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphLookup.IHit"
+                                        },
+                                        description: "Ranked symbol matches for the query."
+                                    },
+                                    unknown: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Query terms that matched nothing."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "hits",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "Targeted symbol lookup when a concrete name or handle is being resolved."
+                            },
+                            "IGraphLookup.IHit": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The hit's declaration signature, so you can often answer without\nrequesting details."
+                                    },
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false,
+                                description: "One ranked hit with a handle to follow via `details` or `trace`."
+                            },
+                            IGraphNext: {
+                                type: "object",
+                                properties: {
+                                    action: {
+                                        type: "string",
+                                        "enum": [
+                                            "answer",
+                                            "clarify",
+                                            "inspect",
+                                            "outside"
+                                        ],
+                                        description: "Answer, continue graph inspection, leave graph, or clarify.\n\n`answer` means the returned graph result already carries the evidence\ncontract for the current question, even when the slice is capped. Do not\ncall graph again or read files to re-check or complete it."
+                                    },
+                                    request: {
+                                        type: "string",
+                                        "enum": [
+                                            "details",
+                                            "entrypoints",
+                                            "lookup",
+                                            "overview",
+                                            "tour",
+                                            "trace"
+                                        ],
+                                        description: "Smallest graph request type to use when `action` is `inspect`."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why the returned graph evidence supports that action."
+                                    }
+                                },
+                                required: [
+                                    "action",
+                                    "reason"
+                                ],
+                                additionalProperties: false,
+                                description: "The required next step from a language-server-derived graph result."
+                            },
+                            IGraphOverview: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    project: {
+                                        type: "string",
+                                        description: "Absolute project root."
+                                    },
+                                    languages: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/GraphLanguage"
+                                        },
+                                        description: "Languages present in the project."
+                                    },
+                                    counts: {
+                                        $ref: "#/$defs/IGraphOverview.ICounts",
+                                        description: "Size of the graph."
+                                    },
+                                    layers: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.ILayer"
+                                        },
+                                        description: "Folder layering, largest first."
+                                    },
+                                    hotspots: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.IHotspot"
+                                        },
+                                        description: "Highest-dependency symbols, busiest first."
+                                    },
+                                    publicApi: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.INode"
+                                        },
+                                        description: "Exported API symbols, most-depended-on first."
+                                    },
+                                    diagnostics: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDiagnostic"
+                                        },
+                                        description: "Index diagnostics, when any."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "project",
+                                    "languages",
+                                    "counts",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "A compact, source-read-free project map for broad orientation only."
+                            },
+                            "IGraphOverview.ICounts": {
+                                type: "object",
+                                properties: {
+                                    files: {
+                                        type: "number",
+                                        description: "Number of source file container nodes."
+                                    },
+                                    nodes: {
+                                        type: "number",
+                                        description: "Total node count, including declarations and file containers."
+                                    },
+                                    edges: {
+                                        type: "number",
+                                        description: "Total edge count, including structural edges."
+                                    },
+                                    byKind: {
+                                        $ref: "#/$defs/Recordstringnumber",
+                                        description: "Node count per kind."
+                                    },
+                                    byLanguage: {
+                                        $ref: "#/$defs/Recordstringnumber",
+                                        description: "Node count per language."
+                                    }
+                                },
+                                required: [
+                                    "files",
+                                    "nodes",
+                                    "edges",
+                                    "byKind",
+                                    "byLanguage"
+                                ],
+                                additionalProperties: false,
+                                description: "Size of the graph by node/edge totals and per-kind node counts."
+                            },
+                            "IGraphOverview.IHotspot": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    fanIn: {
+                                        type: "number",
+                                        description: "Non-structural edges pointing at this symbol."
+                                    },
+                                    fanOut: {
+                                        type: "number",
+                                        description: "Non-structural edges leaving this symbol."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file",
+                                    "fanIn",
+                                    "fanOut"
+                                ],
+                                additionalProperties: false,
+                                description: "A high-dependency symbol with its non-structural fan-in and fan-out."
+                            },
+                            "IGraphOverview.ILayer": {
+                                type: "object",
+                                properties: {
+                                    dir: {
+                                        type: "string",
+                                        description: "Directory, project-relative."
+                                    },
+                                    files: {
+                                        type: "number",
+                                        description: "Distinct source files under it."
+                                    },
+                                    exported: {
+                                        type: "number",
+                                        description: "Exported symbols declared under it."
+                                    },
+                                    languages: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/GraphLanguage"
+                                        },
+                                        description: "Languages present under it."
+                                    }
+                                },
+                                required: [
+                                    "dir",
+                                    "files",
+                                    "exported",
+                                    "languages"
+                                ],
+                                additionalProperties: false,
+                                description: "One folder layer: its source files and export surface."
+                            },
+                            "IGraphOverview.INode": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file"
+                                ],
+                                additionalProperties: false,
+                                description: "A compact symbol coordinate that can be passed to deeper graph tools."
+                            },
+                            IGraphTour: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "tour"
+                                        ],
+                                        description: "Discriminator for code-tour indexing."
+                                    },
+                                    question: {
+                                        type: "string",
+                                        description: "Natural code question this tour was built for."
+                                    },
+                                    entrypoints: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphEntrypoints.IEntrypoint"
+                                        },
+                                        description: "Central entrypoints selected for the tour."
+                                    },
+                                    primaryFlow: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Selected primary runtime flows; sufficient for an index-level tour."
+                                    },
+                                    nearbyPaths: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.INode"
+                                        },
+                                        description: "Nearby dependency anchors around the selected entrypoints."
+                                    },
+                                    testAnchors: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.INode"
+                                        },
+                                        description: "Test or usage anchors reached through graph impact edges."
+                                    },
+                                    answerAnchors: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphOverview.INode"
+                                        },
+                                        description: "Ordered file/line anchors to cite in the final answer, not file reads."
+                                    },
+                                    diagnostics: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphDiagnostic"
+                                        },
+                                        description: "Diagnostics collected while building the tour."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "entrypoints",
+                                    "primaryFlow",
+                                    "nearbyPaths",
+                                    "testAnchors",
+                                    "answerAnchors",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "Answer-ready, source-free tour evidence for broad code-flow questions."
+                            },
+                            IGraphTrace: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    start: {
+                                        $ref: "#/$defs/IGraphTrace.INode",
+                                        description: "The resolved start node, or undefined when `from` matched nothing."
+                                    },
+                                    direction: {
+                                        type: "string",
+                                        description: "Trace direction actually used by this result."
+                                    },
+                                    hops: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphTrace.IHop"
+                                        },
+                                        description: "Edges traversed, in breadth-first order."
+                                    },
+                                    reached: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphTrace.INode"
+                                        },
+                                        description: "Unique nodes reached (excluding the start), each with its depth and roles."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when the trace hit maxNodes or maxDepth and more flow exists."
+                                    },
+                                    target: {
+                                        $ref: "#/$defs/IGraphTrace.INode",
+                                        description: "The resolved `to` target, when a path was requested."
+                                    },
+                                    path: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphTrace.INode"
+                                        },
+                                        description: "When `to` was given: the ordered dependency path from `from` to `to`\n(`from` first, `to` last), or empty when `to` is not reachable from\n`from`."
+                                    },
+                                    steps: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Compact hop summaries preserving node names and edge evidence, capped."
+                                    },
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/IGraphTrace.INode"
+                                        },
+                                        description: "When `from` was an ambiguous name, the matches to disambiguate with."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/IGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "direction",
+                                    "hops",
+                                    "reached",
+                                    "truncated",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false,
+                                description: "The compact dependency or caller flow returned from a selected start symbol."
+                            },
+                            "IGraphTrace.IHop": {
+                                type: "object",
+                                properties: {
+                                    from: {
+                                        type: "string",
+                                        description: "Source node id for this traversed edge."
+                                    },
+                                    to: {
+                                        type: "string",
+                                        description: "Target node id for this traversed edge."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Edge kind (`calls`, `type_ref`, `accesses`, ...)."
+                                    },
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start (1 = direct)."
+                                    },
+                                    evidence: {
+                                        $ref: "#/$defs/IGraphEvidence",
+                                        description: "Source span for the expression that produced this hop. It is repository\nevidence for the hop and can be cited without opening the file."
+                                    }
+                                },
+                                required: [
+                                    "from",
+                                    "to",
+                                    "kind",
+                                    "depth"
+                                ],
+                                additionalProperties: false,
+                                description: "One traversed edge, with its depth from the start."
+                            },
+                            "IGraphTrace.INode": {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    language: {
+                                        $ref: "#/$defs/GraphLanguage",
+                                        description: "Language the symbol is written in."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickIGraphEvidenceendLinefilestartLine",
+                                        description: "Source span of the declaration, when known."
+                                    },
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start, on a reached node."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The node's signature, carried on path nodes so the path explains itself."
+                                    },
+                                    roles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Why this node matters to an impact trace: `exported`, `test`."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "language",
+                                    "file"
+                                ],
+                                additionalProperties: false,
+                                description: "A node on the trace: the start, a reached node, or a candidate."
+                            },
+                            PickIGraphEvidenceendLinefilestartLine: {
+                                type: "object",
+                                properties: {
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    },
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false
+                            },
+                            Recordstringnumber: {
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    type: "number"
+                                }
+                            }
+                        }
+                    },
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            question: {
+                                type: "string",
+                                description: "User's code question.\n\nRestate the code question being considered. If the next evidence is a\nscript, config, doc, generated output, exact text, a file outside the\nindexed languages, or source body text, choose `escape`."
+                            },
+                            draft: {
+                                $ref: "#/$defs/ISamchonGraphApplication.IDraft",
+                                description: "Initial request plan before final arguments are filled.\n\nName the intended request type in `type` and why it seems smallest in\n`reason`. Broad flow, architecture, repository-orientation, and read-next\nquestions should normally draft `tour`; narrow named symbols can draft\n`lookup`, `trace`, or `details`."
+                            },
+                            review: {
+                                type: "string",
+                                description: "Final self-review before calling.\n\nCorrect a stale, broad, duplicate, or wrong draft here. If broad flow was\nsplit into search/detail steps, switch to `tour`. If graph facts already\nanswer, or prior `next.action` was `answer`, make `request.type` be\n`escape`; do not call graph or read files to re-confirm returned facts."
+                            },
+                            request: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/IGraphOverview.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphDetails.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphEntrypoints.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphEscape.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphLookup.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphTour.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/IGraphTrace.IRequest"
+                                    }
+                                ],
+                                description: "Final graph operation chosen after review, or a no-op escape.",
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/IGraphDetails.IRequest",
+                                        entrypoints: "#/$defs/IGraphEntrypoints.IRequest",
+                                        escape: "#/$defs/IGraphEscape.IRequest",
+                                        lookup: "#/$defs/IGraphLookup.IRequest",
+                                        overview: "#/$defs/IGraphOverview.IRequest",
+                                        tour: "#/$defs/IGraphTour.IRequest",
+                                        trace: "#/$defs/IGraphTrace.IRequest"
+                                    },
+                                    propertyName: "type"
+                                }
+                            }
+                        },
+                        required: [
+                            "question",
+                            "draft",
+                            "review",
+                            "request"
+                        ],
+                        additionalProperties: false,
+                        description: "Draft, review, then submit exactly one graph request or escape.",
+                        $defs: {
+                            "IGraphDetails.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    handles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Node ids from another tool, or dotted symbol handles such as\n`OrderService.create`. Pass the few handles you need for source-free\ndetails. Prefer one to three handles. Use `trace` when you need a path\ninstead of widening this call."
+                                    },
+                                    neighbors: {
+                                        type: "boolean",
+                                        description: "Also list each node's direct dependencies and dependents (the symbols it\nuses and the symbols that use it). The list is capped; raise\n`neighborLimit` when the first slice is truncated and the missing\nrelation is named. This remains a relationship summary, not a file body."
+                                    },
+                                    neighborLimit: {
+                                        type: "number",
+                                        description: "Maximum dependencies and dependents to return per side when\n`neighbors:true`.\n\nPrefer the default. Values above a few neighbors are usually overfetch;\ncall `trace` for flow instead."
+                                    },
+                                    memberLimit: {
+                                        type: "number",
+                                        description: "Maximum owned members to return for a container or object literal. Raise\nonly when the first outline is truncated and the missing member is\nnamed."
+                                    },
+                                    dependencyLimit: {
+                                        type: "number",
+                                        description: "Maximum direct execution and type references to return per group. Raise\nonly when the first dependency slice is truncated and the missing\ndependency is named."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary references from bundled libraries. Leave\nfalse for source-architecture answers; enable only when external\ntype/API boundaries are the question."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "handles"
+                                ],
+                                additionalProperties: false,
+                                description: "Which selected handles to inspect, and how much of each to return."
+                            },
+                            "IGraphEntrypoints.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "A natural code question or search phrase. Mix prose with code handles,\nfor example `how Repository.find loads relations` or\n`SelectQueryBuilder.setFindOptions join aliases`. Keep this close to the\nuser's question; do not turn it into a broad keyword dump."
+                                    },
+                                    language: {
+                                        type: "string",
+                                        "enum": [
+                                            "bash",
+                                            "c",
+                                            "cpp",
+                                            "csharp",
+                                            "dart",
+                                            "go",
+                                            "java",
+                                            "javascript",
+                                            "kotlin",
+                                            "lua",
+                                            "php",
+                                            "python",
+                                            "ruby",
+                                            "rust",
+                                            "scala",
+                                            "swift",
+                                            "typescript",
+                                            "unknown",
+                                            "zig"
+                                        ],
+                                        description: "Target source language for the entrypoints."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum ranked hits to return.\n\nPrefer the default. Raise only when the first result was truncated and\nthe missing handle is named."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false,
+                                description: "Ask for first handles when the question is narrow but the symbol is not yet\nknown. For broad tours, read-next, architecture, or multi-phase runtime\nflow, use `tour` instead of decomposing the answer into entrypoints and\nfollow-up calls."
+                            },
+                            "IGraphEscape.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run.\n\nUse this only when the next evidence is outside the indexed code\ngraph: package scripts, config files, generated output, prose docs, exact\ntext, or exact source body text. Name the smallest returned sourceSpan\nwhen source body text is truly required."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The final non-graph note, if useful.\n\nKeep this short. Examples: `answer from the prior graph result`, `source\nbody needed at returned sourceSpan`, or `ask the user for a concrete\nsymbol`."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "reason"
+                                ],
+                                additionalProperties: false,
+                                description: "Skip graph work when graph evidence is unnecessary or exhausted."
+                            },
+                            "IGraphLookup.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "What to find, in natural language and code vocabulary mixed freely: a\nsymbol name, a dotted member (`Service.create`), or a short phrase\n(`request handler`). Exact names are not required, but this is not a\nsecond broad entrypoints call. Use it when a named handle is missing or\nambiguous."
+                                    },
+                                    language: {
+                                        type: "string",
+                                        "enum": [
+                                            "bash",
+                                            "c",
+                                            "cpp",
+                                            "csharp",
+                                            "dart",
+                                            "go",
+                                            "java",
+                                            "javascript",
+                                            "kotlin",
+                                            "lua",
+                                            "php",
+                                            "python",
+                                            "ruby",
+                                            "rust",
+                                            "scala",
+                                            "swift",
+                                            "typescript",
+                                            "unknown",
+                                            "zig"
+                                        ],
+                                        description: "Restrict hits to this language."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        "enum": [
+                                            "class",
+                                            "constructor",
+                                            "enum",
+                                            "external_symbol",
+                                            "field",
+                                            "file",
+                                            "function",
+                                            "interface",
+                                            "method",
+                                            "module",
+                                            "namespace",
+                                            "package",
+                                            "parameter",
+                                            "property",
+                                            "type",
+                                            "variable"
+                                        ],
+                                        description: "Restrict hits to this declaration kind."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum hits to return.\n\nPrefer the default. Large hit lists usually mean the query is too broad;\nrefine the name instead of raising this."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary declarations from bundled libraries. Leave\nfalse for project-source answers; enable only when external type/API\nboundaries are the question."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false,
+                                description: "Find a concrete class, method, function, property, type, or dotted handle."
+                            },
+                            "IGraphOverview.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    aspect: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "diagnostics",
+                                            "hotspots",
+                                            "layers",
+                                            "publicApi"
+                                        ],
+                                        description: "The facet to project, or `all` for every facet. `layers` is the folder\nlayering, `hotspots` the highest-dependency symbols, `publicApi` the\nexported API symbols ranked by how depended-on they are.\n\nUse this only for broad public API or layer orientation. For behavior,\nlifecycle, request-flow, rendering-flow, validation-flow, caller, or\ndependency questions, use `entrypoints` then `trace` instead."
+                                    }
+                                },
+                                required: [
+                                    "type"
+                                ],
+                                additionalProperties: false,
+                                description: "Which broad architecture facets `overview` should return."
+                            },
+                            "IGraphTour.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "tour"
+                                        ],
+                                        description: "Discriminator for code-tour indexing."
+                                    },
+                                    question: {
+                                        type: "string",
+                                        description: "The user's natural code-tour question."
+                                    },
+                                    language: {
+                                        type: "string",
+                                        "enum": [
+                                            "bash",
+                                            "c",
+                                            "cpp",
+                                            "csharp",
+                                            "dart",
+                                            "go",
+                                            "java",
+                                            "javascript",
+                                            "kotlin",
+                                            "lua",
+                                            "php",
+                                            "python",
+                                            "ruby",
+                                            "rust",
+                                            "scala",
+                                            "swift",
+                                            "typescript",
+                                            "unknown",
+                                            "zig"
+                                        ],
+                                        description: "Target source language for the tour."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum central entrypoints to seed the tour.\n\nPrefer the default. Raise only when the question names several distinct\npublic paths that must all appear in one answer."
+                                    }
+                                },
+                                required: [
+                                    "type"
+                                ],
+                                additionalProperties: false,
+                                description: "Build the complete index-level answer surface for broad code tours: central\nentrypoints, primary flow, nearby paths, tests, and answer anchors. Use\nthis instead of decomposing repository-orientation, read-next,\narchitecture, or multi-phase runtime-flow questions into many\nlookup/details/trace calls."
+                            },
+                            "IGraphTrace.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    from: {
+                                        type: "string",
+                                        description: "Where to start: a node id from another tool, a simple symbol name, or a\ndotted member name such as `OrderService.create`. An ambiguous name\nreturns its candidates instead of a trace."
+                                    },
+                                    to: {
+                                        type: "string",
+                                        description: "A target symbol: node id, simple symbol name, or dotted member name. When\ngiven, the tool returns the dependency path from `from` to this target,\nthe one-call answer for \"how does A reach B\", instead of an open-ended\ntrace. Prefer this path mode whenever both ends are known."
+                                    },
+                                    direction: {
+                                        type: "string",
+                                        "enum": [
+                                            "forward",
+                                            "impact",
+                                            "reverse"
+                                        ],
+                                        description: "`forward` follows what the start uses (callees, instantiations, renders);\n`reverse` follows what uses the start (callers); `impact` is a reverse\ntrace that prioritizes public API and test nodes a change would reach.\nIts test nodes are semantic usage edges, not a text-search inventory.\nCaller questions usually fit `reverse`."
+                                    },
+                                    focus: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "execution",
+                                            "types"
+                                        ],
+                                        description: "Which non-structural edge family to follow: `execution` follows runtime\ncalls, instantiations, property access, and JSX renders; `types` follows\ntype references and inheritance; `all` preserves the full graph. Flow\nquestions should usually choose `execution` rather than `all`."
+                                    },
+                                    maxDepth: {
+                                        type: "number",
+                                        description: "How many hops deep to follow. Open forward/reverse traces are capped at\n2; impact traces at 4; path mode at 12.\n\nPrefer the default for open traces. Raise only for path mode or when the\nprevious trace named the missing next hop."
+                                    },
+                                    maxNodes: {
+                                        type: "number",
+                                        description: "Cap on reached nodes; the trace stops and marks itself truncated past it.\nOpen forward/reverse traces are capped at 8 nodes, impact at 16 nodes.\n\nPrefer the default; use larger open traces only when a named missing edge\nrequires it."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary nodes from bundled libraries. Leave false for\nsource-flow tours; enable only when the user asks about external type/API\nboundaries."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "from"
+                                ],
+                                additionalProperties: false,
+                                description: "Where and how far to trace dependency flow."
+                            },
+                            "ISamchonGraphApplication.IDraft": {
+                                type: "object",
+                                properties: {
+                                    reason: {
+                                        type: "string",
+                                        description: "Why this request type looks like the smallest useful next step."
+                                    },
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details",
+                                            "entrypoints",
+                                            "escape",
+                                            "lookup",
+                                            "overview",
+                                            "tour",
+                                            "trace"
+                                        ],
+                                        description: "The request type being considered, corrected later in `review`."
+                                    }
+                                },
+                                required: [
+                                    "reason",
+                                    "type"
+                                ],
+                                additionalProperties: false,
+                                description: "First-pass request plan, filled before the final `request` arguments.\n\n`reason` comes before `type` so the justification is written before the\nchoice it justifies."
+                            }
+                        }
+                    },
+                    validate: (() => {
+                        const _ip0 = input => "string" === typeof input["reason"];
+                        const _ip1 = input => undefined === input["includeExternal"] || "boolean" === typeof input["includeExternal"];
+                        const _ip2 = input => "string" === typeof input["query"];
+                        const _ip3 = input => undefined === input["language"] || true === _iv0.has(input["language"]);
+                        const _iv0 = new Set(["bash", "c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "unknown", "zig"]);
+                        const _ip4 = input => undefined === input["limit"] || "number" === typeof input["limit"];
+                        const _iv1 = new Set(["class", "constructor", "enum", "external_symbol", "field", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+                        const _ve0 = "(IGraphDetails.IRequest | IGraphEntrypoints.IRequest | IGraphEscape.IRequest | IGraphLookup.IRequest | IGraphOverview.IRequest | IGraphTour.IRequest | IGraphTrace.IRequest)";
+                        const _vp0 = (input, _path, _exceptionable = true) => "string" === typeof input["reason"] || _report(_exceptionable, {
+                            path: _path + ".reason",
+                            expected: "string",
+                            value: input["reason"]
+                        });
+                        const _vp1 = (input, _path, _exceptionable = true) => undefined === input["includeExternal"] || "boolean" === typeof input["includeExternal"] || _report(_exceptionable, {
+                            path: _path + ".includeExternal",
+                            expected: "(boolean | undefined)",
+                            value: input["includeExternal"]
+                        });
+                        const _vp2 = (input, _path, _exceptionable = true) => "string" === typeof input["query"] || _report(_exceptionable, {
+                            path: _path + ".query",
+                            expected: "string",
+                            value: input["query"]
+                        });
+                        const _vp3 = (input, _path, _exceptionable = true) => undefined === input["language"] || true === _vv0.has(input["language"]) || _report(_exceptionable, {
+                            path: _path + ".language",
+                            expected: _ve1,
+                            value: input["language"]
+                        });
+                        const _vv0 = new Set(["bash", "c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "unknown", "zig"]);
+                        const _ve1 = "(\"bash\" | \"c\" | \"cpp\" | \"csharp\" | \"dart\" | \"go\" | \"java\" | \"javascript\" | \"kotlin\" | \"lua\" | \"php\" | \"python\" | \"ruby\" | \"rust\" | \"scala\" | \"swift\" | \"typescript\" | \"unknown\" | \"zig\" | undefined)";
+                        const _vp4 = (input, _path, _exceptionable = true) => undefined === input["limit"] || "number" === typeof input["limit"] || _report(_exceptionable, {
+                            path: _path + ".limit",
+                            expected: "(number | undefined)",
+                            value: input["limit"]
+                        });
+                        const _vv1 = new Set(["class", "constructor", "enum", "external_symbol", "field", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+                        const _ve2 = "(\"class\" | \"constructor\" | \"enum\" | \"external_symbol\" | \"field\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\" | undefined)";
+                        const _ve3 = "(IGraphOverview.IRequest | IGraphDetails.IRequest | IGraphEntrypoints.IRequest | IGraphEscape.IRequest | IGraphLookup.IRequest | IGraphTour.IRequest | IGraphTrace.IRequest)";
+                        const _io0 = input => "string" === typeof input.question && ("object" === typeof input.draft && null !== input.draft && _io1(input.draft)) && "string" === typeof input.review && ("object" === typeof input.request && null !== input.request && _iu0(input.request));
+                        const _io1 = input => _ip0(input) && ("details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "tour" === input.type || "trace" === input.type);
+                        const _io2 = input => "overview" === input.type && (undefined === input.aspect || "all" === input.aspect || "diagnostics" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect);
+                        const _io3 = input => "details" === input.type && (Array.isArray(input.handles) && input.handles.every(elem => "string" === typeof elem)) && (undefined === input.neighbors || "boolean" === typeof input.neighbors) && (undefined === input.neighborLimit || "number" === typeof input.neighborLimit) && (undefined === input.memberLimit || "number" === typeof input.memberLimit) && (undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit) && _ip1(input);
+                        const _io4 = input => "entrypoints" === input.type && _ip2(input) && _ip3(input) && _ip4(input);
+                        const _io5 = input => "escape" === input.type && _ip0(input) && (undefined === input.nextStep || "string" === typeof input.nextStep);
+                        const _io6 = input => "lookup" === input.type && _ip2(input) && _ip3(input) && (undefined === input.kind || true === _iv1.has(input.kind)) && _ip4(input) && _ip1(input);
+                        const _io7 = input => "tour" === input.type && (undefined === input.question || "string" === typeof input.question) && _ip3(input) && _ip4(input);
+                        const _io8 = input => "trace" === input.type && "string" === typeof input.from && (undefined === input.to || "string" === typeof input.to) && (undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction) && (undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus) && (undefined === input.maxDepth || "number" === typeof input.maxDepth) && (undefined === input.maxNodes || "number" === typeof input.maxNodes) && _ip1(input);
+                        const _iu0 = input => (() => {
+                            if ("overview" === input.type)
+                                return _io2(input);
+                            else if ("details" === input.type)
+                                return _io3(input);
+                            else if ("entrypoints" === input.type)
+                                return _io4(input);
+                            else if ("escape" === input.type)
+                                return _io5(input);
+                            else if ("lookup" === input.type)
+                                return _io6(input);
+                            else if ("tour" === input.type)
+                                return _io7(input);
+                            else if ("trace" === input.type)
+                                return _io8(input);
+                            else
+                                return false;
+                        })();
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.question || _report(_exceptionable, {
+                                path: _path + ".question",
+                                expected: "string",
+                                value: input.question
+                            }), ("object" === typeof input.draft && null !== input.draft || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ISamchonGraphApplication.IDraft",
+                                value: input.draft
+                            })) && _vo1(input.draft, _path + ".draft", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ISamchonGraphApplication.IDraft",
+                                value: input.draft
+                            }), "string" === typeof input.review || _report(_exceptionable, {
+                                path: _path + ".review",
+                                expected: "string",
+                                value: input.review
+                            }), ("object" === typeof input.request && null !== input.request || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: _ve0,
+                                value: input.request
+                            })) && _vu0(input.request, _path + ".request", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: _ve0,
+                                value: input.request
+                            })].every(flag => flag);
+                        const _vo1 = (input, _path, _exceptionable = true) => [_vp0(input, _path, true && _exceptionable), "details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "tour" === input.type || "trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "(\"details\" | \"entrypoints\" | \"escape\" | \"lookup\" | \"overview\" | \"tour\" | \"trace\")",
+                                value: input.type
+                            })].every(flag => flag);
+                        const _vo2 = (input, _path, _exceptionable = true) => ["overview" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"overview\"",
+                                value: input.type
+                            }), undefined === input.aspect || "all" === input.aspect || "diagnostics" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect || _report(_exceptionable, {
+                                path: _path + ".aspect",
+                                expected: "(\"all\" | \"diagnostics\" | \"hotspots\" | \"layers\" | \"publicApi\" | undefined)",
+                                value: input.aspect
+                            })].every(flag => flag);
+                        const _vo3 = (input, _path, _exceptionable = true) => ["details" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"details\"",
+                                value: input.type
+                            }), (Array.isArray(input.handles) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            })) && input.handles.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+                                path: _path + ".handles[" + _index2 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            }), undefined === input.neighbors || "boolean" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(boolean | undefined)",
+                                value: input.neighbors
+                            }), undefined === input.neighborLimit || "number" === typeof input.neighborLimit || _report(_exceptionable, {
+                                path: _path + ".neighborLimit",
+                                expected: "(number | undefined)",
+                                value: input.neighborLimit
+                            }), undefined === input.memberLimit || "number" === typeof input.memberLimit || _report(_exceptionable, {
+                                path: _path + ".memberLimit",
+                                expected: "(number | undefined)",
+                                value: input.memberLimit
+                            }), undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit || _report(_exceptionable, {
+                                path: _path + ".dependencyLimit",
+                                expected: "(number | undefined)",
+                                value: input.dependencyLimit
+                            }), _vp1(input, _path, true && _exceptionable)].every(flag => flag);
+                        const _vo4 = (input, _path, _exceptionable = true) => ["entrypoints" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"entrypoints\"",
+                                value: input.type
+                            }), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), _vp4(input, _path, true && _exceptionable)].every(flag => flag);
+                        const _vo5 = (input, _path, _exceptionable = true) => ["escape" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"escape\"",
+                                value: input.type
+                            }), _vp0(input, _path, true && _exceptionable), undefined === input.nextStep || "string" === typeof input.nextStep || _report(_exceptionable, {
+                                path: _path + ".nextStep",
+                                expected: "(string | undefined)",
+                                value: input.nextStep
+                            })].every(flag => flag);
+                        const _vo6 = (input, _path, _exceptionable = true) => ["lookup" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"lookup\"",
+                                value: input.type
+                            }), _vp2(input, _path, true && _exceptionable), _vp3(input, _path, true && _exceptionable), undefined === input.kind || true === _vv1.has(input.kind) || _report(_exceptionable, {
+                                path: _path + ".kind",
+                                expected: _ve2,
+                                value: input.kind
+                            }), _vp4(input, _path, true && _exceptionable), _vp1(input, _path, true && _exceptionable)].every(flag => flag);
+                        const _vo7 = (input, _path, _exceptionable = true) => ["tour" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"tour\"",
+                                value: input.type
+                            }), undefined === input.question || "string" === typeof input.question || _report(_exceptionable, {
+                                path: _path + ".question",
+                                expected: "(string | undefined)",
+                                value: input.question
+                            }), _vp3(input, _path, true && _exceptionable), _vp4(input, _path, true && _exceptionable)].every(flag => flag);
+                        const _vo8 = (input, _path, _exceptionable = true) => ["trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"trace\"",
+                                value: input.type
+                            }), "string" === typeof input.from || _report(_exceptionable, {
+                                path: _path + ".from",
+                                expected: "string",
+                                value: input.from
+                            }), undefined === input.to || "string" === typeof input.to || _report(_exceptionable, {
+                                path: _path + ".to",
+                                expected: "(string | undefined)",
+                                value: input.to
+                            }), undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction || _report(_exceptionable, {
+                                path: _path + ".direction",
+                                expected: "(\"forward\" | \"impact\" | \"reverse\" | undefined)",
+                                value: input.direction
+                            }), undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus || _report(_exceptionable, {
+                                path: _path + ".focus",
+                                expected: "(\"all\" | \"execution\" | \"types\" | undefined)",
+                                value: input.focus
+                            }), undefined === input.maxDepth || "number" === typeof input.maxDepth || _report(_exceptionable, {
+                                path: _path + ".maxDepth",
+                                expected: "(number | undefined)",
+                                value: input.maxDepth
+                            }), undefined === input.maxNodes || "number" === typeof input.maxNodes || _report(_exceptionable, {
+                                path: _path + ".maxNodes",
+                                expected: "(number | undefined)",
+                                value: input.maxNodes
+                            }), _vp1(input, _path, true && _exceptionable)].every(flag => flag);
+                        const _vu0 = (input, _path, _exceptionable = true) => (() => {
+                            if ("overview" === input.type)
+                                return _vo2(input, _path, true && _exceptionable);
+                            else if ("details" === input.type)
+                                return _vo3(input, _path, true && _exceptionable);
+                            else if ("entrypoints" === input.type)
+                                return _vo4(input, _path, true && _exceptionable);
+                            else if ("escape" === input.type)
+                                return _vo5(input, _path, true && _exceptionable);
+                            else if ("lookup" === input.type)
+                                return _vo6(input, _path, true && _exceptionable);
+                            else if ("tour" === input.type)
+                                return _vo7(input, _path, true && _exceptionable);
+                            else if ("trace" === input.type)
+                                return _vo8(input, _path, true && _exceptionable);
+                            else
+                                return _report(_exceptionable, {
+                                    path: _path,
+                                    expected: _ve3,
+                                    value: input
+                                });
+                        })();
+                        const __is = input => "object" === typeof input && null !== input && _io0(input);
+                        let errors;
+                        let _report;
+                        return input => {
+                            if (false === __is(input)) {
+                                errors = [];
+                                _report = _b._validateReport(errors);
+                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                                    path: _path + "",
+                                    expected: "ISamchonGraphApplication.IProps",
+                                    value: input
+                                })) && _vo0(input, _path + "", true) || _report(true, {
+                                    path: _path + "",
+                                    expected: "ISamchonGraphApplication.IProps",
+                                    value: input
+                                }))(input, "$input", true);
+                                const success = 0 === errors.length;
+                                return success ? {
+                                    success,
+                                    data: input
+                                } : {
+                                    success,
+                                    errors,
+                                    data: input
+                                };
+                            }
+                            return {
+                                success: true,
+                                data: input
+                            };
+                        };
+                    })()
+                }
+            ]
+        }),
+        execute: new application_1.SamchonGraphApplication(graph),
+    };
+    return (0, mcp_1.createMcpServer)(controller, version);
+}
+//# sourceMappingURL=createServer.js.map