@ttsc/graph 0.16.10 → 0.16.12

package/lib/structures/ITtscGraphDetails.d.ts

@@ -0,0 +1,157 @@
+import { ITtscGraphDecorator } from "./ITtscGraphDecorator";
+import { ITtscGraphEvidence } from "./ITtscGraphEvidence";
+import { ITtscGraphNext } from "./ITtscGraphNext";
+/**
+ * The source-free facts for a few selected handles.
+ *
+ * This is not a file reader. It returns signatures, member outlines, direct
+ * calls, direct types, implementation candidates, dependency summaries, and
+ * sourceSpan citation anchors.
+ */
+export interface ITtscGraphDetails {
+    /** Discriminator for selected symbol inspection. */
+    type: "details";
+    /** Selected node facts, in the same order as resolved handles when possible. */
+    nodes: ITtscGraphDetails.INode[];
+    /** How to use this source-free result next. */
+    next: ITtscGraphNext;
+    /** Human-readable compatibility note mirroring `next`. */
+    guide: string;
+    /** Handles that resolved to no node, or that were ambiguous. */
+    unknown: string[];
+}
+export declare namespace ITtscGraphDetails {
+    /** Which selected handles to inspect, and how much of each to return. */
+    interface IRequest {
+        /** Discriminator for selected symbol inspection. */
+        type: "details";
+        /**
+         * Node ids from another tool, or dotted symbol handles such as
+         * `OrderService.create`. Pass the few handles you need for source-free
+         * details. Prefer one to three handles. Use `trace` when you need a path
+         * instead of widening this call.
+         */
+        handles: string[];
+        /**
+         * Also list each node's direct dependencies and dependents (the symbols it
+         * uses and the symbols that use it). The list is capped; raise
+         * `neighborLimit` when the first slice is truncated and the missing
+         * relation is named. This remains a relationship summary, not a file body.
+         *
+         * @default false
+         */
+        neighbors?: boolean;
+        /**
+         * Maximum dependencies and dependents to return per side when
+         * `neighbors:true`.
+         *
+         * Prefer the default. Values above a few neighbors are usually overfetch;
+         * call `trace` for flow instead.
+         *
+         * @default 2
+         */
+        neighborLimit?: number;
+        /**
+         * Maximum owned members to return for a container or object literal. Raise
+         * only when the first outline is truncated and the missing member is
+         * named.
+         *
+         * @default 6
+         */
+        memberLimit?: number;
+        /**
+         * Maximum direct execution and type references to return per group. Raise
+         * only when the first dependency slice is truncated and the missing
+         * dependency is named.
+         *
+         * @default 1
+         */
+        dependencyLimit?: number;
+        /**
+         * Include dependency-boundary references from node_modules or bundled
+         * `.d.ts` libraries. Leave false for source-architecture answers; enable
+         * only when external type/API boundaries are the question.
+         *
+         * @default false
+         */
+        includeExternal?: boolean;
+    }
+    /** One inspected node: its declared shape and graph coordinates. */
+    interface INode {
+        /** Stable node id for subsequent `details` or `trace` calls. */
+        id: string;
+        /** Qualified symbol name when available, otherwise the simple name. */
+        name: string;
+        /** Declaration kind (`class`, `method`, `function`, ...). */
+        kind: string;
+        /** Project-relative path of the file that declares this node. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /** The declaration signature: its first line(s) up to the body. */
+        signature?: string;
+        /** Decorators written on this declaration, when any. */
+        decorators?: ITtscGraphDecorator[];
+        /** Assigned implementation span, when source comes from one. */
+        implementation?: ITtscGraphEvidence;
+        /** Direct execution dependencies in source order, with edge evidence. */
+        calls?: IReference[];
+        /** Direct type dependencies in source order, with edge evidence. */
+        types?: IReference[];
+        /** Concrete nodes that implement or override this interface/base member. */
+        implementedBy?: IReference[];
+        /** String literal values from the signature. */
+        literals?: string[];
+        /**
+         * For a container or object-literal variable: the owned symbol or top-level
+         * property outline a consumer reaches for, without bodies.
+         */
+        members?: IMember[];
+        /** Declaration or implementation citation range, when known. */
+        sourceSpan?: Pick<ITtscGraphEvidence, "file" | "startLine" | "endLine">;
+        /** Symbols this node uses (outgoing dependency edges). */
+        dependsOn?: IReference[];
+        /** Symbols that use this node (incoming dependency edges). */
+        dependedOnBy?: IReference[];
+    }
+    /** One member of a container node, with its signature but not its body. */
+    interface IMember {
+        /** Member name, qualified when the graph records an owner-qualified handle. */
+        name: string;
+        /** Member kind (`method`, `property`, `class`, ...). */
+        kind: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /** The member's declaration signature. */
+        signature?: string;
+        /** Decorators written on this member, when any. */
+        decorators?: ITtscGraphDecorator[];
+    }
+    /** A dependency neighbor of an inspected node and the edge that links them. */
+    interface IReference {
+        /** Stable id of the neighboring node. */
+        id: string;
+        /** Neighbor symbol name, qualified when available. */
+        name: string;
+        /** Neighbor declaration kind. */
+        kind: string;
+        /** Project-relative declaration file for the neighbor. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /** The edge kind connecting the two (`calls`, `type_ref`, ...). */
+        relation: string;
+        /**
+         * Source span for the expression that produced this relationship. It is
+         * repository evidence for the edge, not a file-read instruction.
+         */
+        evidence?: ITtscGraphEvidence;
+        /**
+         * Stable access-path aliases derived from edge evidence. For example, an
+         * edge to `Owner.member` through `obj.slot.member` may expose
+         * `Owner.slot.member` so answers can preserve both the resolved symbol and
+         * the source access path.
+         */
+        aliases?: string[];
+    }
+}

package/lib/structures/ITtscGraphDiagnostic.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A compiler or plugin diagnostic, fused onto the graph so an edit-triage query
+ * can name the owning symbol of an error.
+ *
+ * The TypeScript semantic pass contributes numeric-coded `tsc` diagnostics;
+ * `@ttsc/lint` rules and transform plugins (typia, nestia, …) contribute
+ * `plugin`/`lint` findings whose `code` is a string. `node` is set when the
+ * finding's position was attributed to a graph node.
+ */
+export interface ITtscGraphDiagnostic {
+    /** Project-relative path of the file the diagnostic is reported in. */
+    file: string;
+    /** 1-based line of the diagnostic. */
+    line: number;
+    /** 1-based column of the diagnostic, when known. */
+    column?: number;
+    /** Numeric `tsc` code, or string rule id for a lint/plugin finding. */
+    code: number | string;
+    /** The human-readable diagnostic message. */
+    message: string;
+    /** Severity, when the producer distinguishes it. */
+    severity?: "error" | "warning" | "info" | "hint";
+    /** Which lane produced the diagnostic. */
+    origin?: "tsc" | "plugin" | "lint";
+    /** Node id the diagnostic was fused onto, when resolved. */
+    node?: string;
+}

package/lib/structures/ITtscGraphDump.d.ts

@@ -0,0 +1,30 @@
+import { ITtscGraphDiagnostic } from "./ITtscGraphDiagnostic";
+import { ITtscGraphEdge } from "./ITtscGraphEdge";
+import { ITtscGraphNode } from "./ITtscGraphNode";
+/**
+ * The whole-graph export `ttscgraph dump` writes and the MCP server loads — the
+ * wire contract between the Go fact-builder and the TypeScript graph engine.
+ *
+ * It is the complete graph with none of the per-response caps the MCP tools
+ * apply: every node and edge the build resolved. The server parses it once at
+ * startup (typia-validated) into an in-memory resident graph and answers every
+ * tool call from that warm model; the bundled 3D viewer reduces the same dump.
+ *
+ * Paths in `project` and `tsconfig` are absolute; `file` fields on nodes,
+ * edges, and diagnostics are project-relative.
+ */
+export interface ITtscGraphDump {
+    /** Absolute path of the project root the graph was built for. */
+    project: string;
+    /** The tsconfig the program was loaded from, relative to `project`. */
+    tsconfig: string;
+    /** Every node the build recorded. */
+    nodes: ITtscGraphNode[];
+    /** Every edge the build resolved. */
+    edges: ITtscGraphEdge[];
+    /**
+     * Fused compiler and plugin diagnostics, when diagnostics were collected.
+     * Absent when the dump was built without a diagnostics pass.
+     */
+    diagnostics?: ITtscGraphDiagnostic[];
+}

package/lib/structures/ITtscGraphEdge.d.ts

@@ -0,0 +1,20 @@
+import { ITtscGraphEvidence } from "./ITtscGraphEvidence";
+import { TtscGraphEdgeKind } from "./TtscGraphEdgeKind";
+/**
+ * A directed relationship from one {@link ITtscGraphNode} to another, both named
+ * by `id`. The triple `(from, to, kind)` is unique; a repeated relationship
+ * keeps the first source-order evidence.
+ *
+ * Every edge is resolved by the compiler, so there is no per-edge trust flag to
+ * carry — the whole graph is checker-resolved fact.
+ */
+export interface ITtscGraphEdge {
+    /** Node id the relationship originates from. */
+    from: string;
+    /** Node id the relationship points to. */
+    to: string;
+    /** The relationship kind. */
+    kind: TtscGraphEdgeKind;
+    /** The source expression that produced the edge, for display and expansion. */
+    evidence?: ITtscGraphEvidence;
+}

package/lib/structures/ITtscGraphEntrypoints.d.ts

@@ -0,0 +1,117 @@
+import { ITtscGraphDecorator } from "./ITtscGraphDecorator";
+import { ITtscGraphEvidence } from "./ITtscGraphEvidence";
+import { ITtscGraphNext } from "./ITtscGraphNext";
+/** The first compact source-free handle list for a TypeScript code question. */
+export interface ITtscGraphEntrypoints {
+    /** Discriminator for first-pass question indexing. */
+    type: "entrypoints";
+    /** The original question/search phrase the entrypoints were built for. */
+    query: string;
+    /** Ranked symbols relevant to the query. */
+    hits: ITtscGraphEntrypoints.IHit[];
+    /** Code handles written directly in the query, resolved when possible. */
+    mentions: ITtscGraphEntrypoints.IMention[];
+    /** Direct dependency context for the resolved mentions and highest hits. */
+    neighborhood: ITtscGraphEntrypoints.INeighborhood[];
+    /** How to use this source-free result next. */
+    next: ITtscGraphNext;
+    /** Human-readable compatibility note mirroring `next`. */
+    guide: string;
+    /** True when result caps hid additional seeds or references. */
+    truncated?: boolean;
+}
+export declare namespace ITtscGraphEntrypoints {
+    /**
+     * Ask for first handles when the question is narrow but the symbol is not yet
+     * known. For broad tours, read-next, architecture, or multi-phase runtime
+     * flow, use `tour` instead of decomposing the answer into entrypoints and
+     * follow-up calls.
+     */
+    interface IRequest {
+        /** Discriminator for first-pass question indexing. */
+        type: "entrypoints";
+        /**
+         * A natural code question or search phrase. Mix prose with code handles,
+         * for example `how Repository.find loads relations` or
+         * `SelectQueryBuilder.setFindOptions join aliases`. Keep this close to the
+         * user's question; do not turn it into a broad keyword dump.
+         */
+        query: string;
+        /**
+         * Maximum ranked hits to return.
+         *
+         * Prefer the default. Raise only when the first result was truncated and
+         * the missing handle is named.
+         *
+         * @default 4
+         */
+        limit?: number;
+        /**
+         * Maximum direct dependencies and dependents to return per indexed symbol.
+         * This is an orientation slice, not a dependency dump; use `trace` or
+         * `details` with `neighbors:true` after choosing the specific handles.
+         * Prefer the default zero for the first call.
+         *
+         * @default 0
+         */
+        neighbors?: number;
+    }
+    /** A compact symbol coordinate, optionally with its declaration signature. */
+    interface INode {
+        /** Stable node id for subsequent graph calls. */
+        id: string;
+        /** Qualified symbol name when available, otherwise the simple name. */
+        name: string;
+        /** Declaration kind (`class`, `method`, `function`, ...). */
+        kind: string;
+        /** Project-relative path of the declaration file. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /** Declaration head, included only for indexed symbols. */
+        signature?: string;
+        /** Decorators written on this declaration, when any. */
+        decorators?: ITtscGraphDecorator[];
+    }
+    /** One ranked search hit. */
+    interface IHit extends INode {
+        /** Relative relevance; higher is a better match. */
+        score: number;
+    }
+    /** A code handle written in the query, with its resolution status. */
+    interface IMention {
+        /** The exact handle text found in the query. */
+        handle: string;
+        /** Resolved node when the handle maps unambiguously. */
+        node?: INode;
+        /** Candidate nodes when the handle is ambiguous. */
+        candidates?: INode[];
+    }
+    /** Direct dependency context around one indexed symbol. */
+    interface INeighborhood extends INode {
+        /** Symbols this node directly uses, capped by `neighbors`. */
+        dependsOn: IReference[];
+        /** Symbols that directly use this node, capped by `neighbors`. */
+        dependedOnBy: IReference[];
+    }
+    /** One neighboring symbol and the relationship leading to it. */
+    interface IReference {
+        /** Stable id of the neighboring node. */
+        id: string;
+        /** Neighbor symbol name, qualified when available. */
+        name: string;
+        /** Neighbor declaration kind. */
+        kind: string;
+        /** Project-relative declaration file for the neighbor. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /** Edge kind connecting the indexed node and this neighbor. */
+        relation: string;
+        /**
+         * Source span for the expression that produced this relationship. It lets
+         * an agent see why the edge exists without opening the file.
+         */
+        evidence?: ITtscGraphEvidence;
+    }
+}

package/lib/structures/ITtscGraphEscape.d.ts

@@ -0,0 +1,40 @@
+import { ITtscGraphNext } from "./ITtscGraphNext";
+/** The no-op result for when graph is not the useful next evidence source. */
+export interface ITtscGraphEscape {
+    /** Discriminator for the no-op escape route. */
+    type: "escape";
+    /** Always true so callers can distinguish an intentional no-op. */
+    skipped: true;
+    /** Why no graph operation should run. */
+    reason: string;
+    /** How to proceed after skipping graph work. */
+    next: ITtscGraphNext;
+    /** Human-readable compatibility note mirroring `next`. */
+    guide: string;
+    /** Optional note about the next non-graph step. */
+    nextStep?: string;
+}
+export declare namespace ITtscGraphEscape {
+    /** Skip graph work when graph evidence is unnecessary or exhausted. */
+    interface IRequest {
+        /** Discriminator for the no-op escape route. */
+        type: "escape";
+        /**
+         * Why no graph operation should run.
+         *
+         * Use this only when the next evidence is outside the indexed TypeScript
+         * graph: package scripts, config files, generated output, prose docs, exact
+         * text, or exact source body text. Name the smallest returned sourceSpan
+         * when source body text is truly required.
+         */
+        reason: string;
+        /**
+         * The final non-graph note, if useful.
+         *
+         * Keep this short. Examples: `answer from the prior graph result`, `source
+         * body needed at returned sourceSpan`, or `ask the user for a concrete
+         * symbol`.
+         */
+        nextStep?: string;
+    }
+}

package/lib/structures/ITtscGraphEvidence.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A source location that grounds a node or edge in real code: the declaration
+ * span for a node, or the expression range that produced an edge.
+ *
+ * Evidence is display and grounding only; it is never identity. A node's id is
+ * position-invariant (see {@link ITtscGraphNode}), so an edit that shifts a span
+ * does not re-key anything. `startLine`/`startCol` are 1-based. MCP output
+ * keeps evidence as coordinates; consumers can read the file themselves when
+ * they truly need source text.
+ */
+export interface ITtscGraphEvidence {
+    /** Project-relative path of the file the span lives in. */
+    file: string;
+    /** 1-based line where the span starts. */
+    startLine: number;
+    /** 1-based column where the span starts, when known. */
+    startCol?: number;
+    /** 1-based line where the span ends, when it differs from `startLine`. */
+    endLine?: number;
+    /** 1-based column where the span ends, when known. */
+    endCol?: number;
+}

package/lib/structures/ITtscGraphLookup.d.ts

@@ -0,0 +1,67 @@
+import { ITtscGraphDecorator } from "./ITtscGraphDecorator";
+import { ITtscGraphNext } from "./ITtscGraphNext";
+/** Targeted symbol lookup when a concrete name or handle is being resolved. */
+export interface ITtscGraphLookup {
+    /** Discriminator for targeted symbol lookup. */
+    type: "lookup";
+    /** Ranked symbol matches for the query. */
+    hits: ITtscGraphLookup.IHit[];
+    /** How to use this source-free result next. */
+    next: ITtscGraphNext;
+    /** Human-readable compatibility note mirroring `next`. */
+    guide: string;
+}
+export declare namespace ITtscGraphLookup {
+    /** Find a concrete class, method, function, property, type, or dotted handle. */
+    interface IRequest {
+        /** Discriminator for targeted symbol lookup. */
+        type: "lookup";
+        /**
+         * What to find, in natural language and code vocabulary mixed freely: a
+         * symbol name, a dotted member (`Service.create`), or a short phrase
+         * (`request handler`). Exact names are not required, but this is not a
+         * second broad entrypoints call. Use it when a named handle is missing or
+         * ambiguous.
+         */
+        query: string;
+        /**
+         * Maximum hits to return.
+         *
+         * Prefer the default. Large hit lists usually mean the query is too broad;
+         * refine the name instead of raising this.
+         *
+         * @default 5
+         */
+        limit?: number;
+        /**
+         * Include dependency-boundary declarations from node_modules or bundled
+         * `.d.ts` libraries. Leave false for project-source answers; enable only
+         * when external type/API boundaries are the question.
+         *
+         * @default false
+         */
+        includeExternal?: boolean;
+    }
+    /** One ranked hit with a handle to follow via `details` or `trace`. */
+    interface IHit {
+        /** Stable node id for subsequent graph calls. */
+        id: string;
+        /** Qualified symbol name when available, otherwise the simple name. */
+        name: string;
+        /** Declaration kind (`class`, `method`, `function`, ...). */
+        kind: string;
+        /** Project-relative path of the declaration file. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+        /**
+         * The hit's declaration signature, so you can often answer without
+         * requesting details.
+         */
+        signature?: string;
+        /** Decorators written on this declaration, when any. */
+        decorators?: ITtscGraphDecorator[];
+        /** Relative relevance; higher is a better match. */
+        score: number;
+    }
+}

package/lib/structures/ITtscGraphNext.d.ts

@@ -0,0 +1,15 @@
+/** The required next step from a compiler-derived graph result. */
+export interface ITtscGraphNext {
+    /**
+     * Answer, continue graph inspection, leave graph, or clarify.
+     *
+     * `answer` means the returned graph result already carries the evidence
+     * contract for the current question, even when the slice is capped. Do not
+     * call graph again or read files to re-check or complete it.
+     */
+    action: "answer" | "inspect" | "outside" | "clarify";
+    /** Smallest graph request type to use when `action` is `inspect`. */
+    request?: "entrypoints" | "lookup" | "trace" | "details" | "overview" | "tour";
+    /** Why the returned graph evidence supports that action. */
+    reason: string;
+}

package/lib/structures/ITtscGraphNode.d.ts

@@ -0,0 +1,58 @@
+import { ITtscGraphDecorator } from "./ITtscGraphDecorator";
+import { ITtscGraphEvidence } from "./ITtscGraphEvidence";
+import { TtscGraphNodeKind } from "./TtscGraphNodeKind";
+import { TtscGraphNodeModifier } from "./TtscGraphNodeModifier";
+/**
+ * One node in the graph: a declared symbol or a structural container (file,
+ * package).
+ *
+ * The `id` is position-invariant: `path#qualifiedName:kind` (e.g.
+ * `src/order.ts#OrderService.create:method`), so inserting a line above a
+ * declaration does not re-key it. Line and span live in `evidence` and are
+ * never part of identity.
+ */
+export interface ITtscGraphNode {
+    /** Position-invariant identity (see the interface doc for the id grammar). */
+    id: string;
+    /** What this node represents. */
+    kind: TtscGraphNodeKind;
+    /** The simple, unqualified declared name (`create`, `OrderService`, `App`). */
+    name: string;
+    /**
+     * The owner-qualified name, when the node lives inside another declaration:
+     * `OrderService.create`, `Shopping.ISale`. Absent for a top-level
+     * declaration.
+     */
+    qualifiedName?: string;
+    /** Project-relative path of the file that declares this node. */
+    file: string;
+    /**
+     * True when the declaration lives outside the workspace (a dependency). The
+     * graph keeps the leaf as a named endpoint but does not walk into its
+     * internals.
+     */
+    external: boolean;
+    /**
+     * True when `file` is git-ignored generated code (a Prisma client, a codegen
+     * output). Projections desurface these so generated nodes do not bury the
+     * authored graph.
+     */
+    ignored?: boolean;
+    /** True when the symbol is part of its module's export surface. */
+    exported?: boolean;
+    /** Declaration modifiers, when the declaration pass recorded any. */
+    modifiers?: TtscGraphNodeModifier[];
+    /**
+     * The decorators written on this declaration, in source order, when it has
+     * any: raw decorator facts (`@Controller`, `@Get`) a consumer can interpret
+     * without re-parsing source.
+     */
+    decorators?: ITtscGraphDecorator[];
+    /** The declaration span, for display and signatures. */
+    evidence?: ITtscGraphEvidence;
+    /**
+     * The implementation span when a callable/property member is implemented by a
+     * function assignment separate from its declaration.
+     */
+    implementation?: ITtscGraphEvidence;
+}

package/lib/structures/ITtscGraphOverview.d.ts

@@ -0,0 +1,85 @@
+import { ITtscGraphNext } from "./ITtscGraphNext";
+/** A compact, source-read-free project map for broad orientation only. */
+export interface ITtscGraphOverview {
+    /** Discriminator for source-free project overview. */
+    type: "overview";
+    /** Absolute project root. */
+    project: string;
+    /** Size of the graph. */
+    counts: ITtscGraphOverview.ICounts;
+    /** How to use this source-free result next. */
+    next: ITtscGraphNext;
+    /** Human-readable compatibility note mirroring `next`. */
+    guide: string;
+    /** Folder layering, largest first. */
+    layers?: ITtscGraphOverview.ILayer[];
+    /** Highest-dependency symbols, busiest first. */
+    hotspots?: ITtscGraphOverview.IHotspot[];
+    /** Exported API symbols, most-depended-on first. */
+    publicApi?: ITtscGraphOverview.IPublicApi[];
+}
+export declare namespace ITtscGraphOverview {
+    /** Which broad architecture facets `overview` should return. */
+    interface IRequest {
+        /** Discriminator for source-free project overview. */
+        type: "overview";
+        /**
+         * The facet to project, or `all` for every facet. `layers` is the folder
+         * layering, `hotspots` the highest-dependency symbols, `publicApi` the
+         * exported API symbols ranked by how depended-on they are.
+         *
+         * Use this only for broad public API or layer orientation. For behavior,
+         * lifecycle, request-flow, rendering-flow, validation-flow, caller, or
+         * dependency questions, use `entrypoints` then `trace` instead.
+         *
+         * @default "all"
+         */
+        aspect?: "all" | "layers" | "hotspots" | "publicApi";
+    }
+    /** Size of the graph by node/edge totals and per-kind node counts. */
+    interface ICounts {
+        /** Number of source file container nodes. */
+        files: number;
+        /** Total node count, including declarations and file containers. */
+        nodes: number;
+        /** Total edge count, including structural edges. */
+        edges: number;
+        /** Node count per kind. */
+        byKind: Record<string, number>;
+    }
+    /** One folder layer: its source files and export surface. */
+    interface ILayer {
+        /** Directory, project-relative. */
+        dir: string;
+        /** Distinct source files under it. */
+        files: number;
+        /** Exported symbols declared under it. */
+        exported: number;
+    }
+    /** A compact symbol coordinate that can be passed to deeper graph tools. */
+    interface INode {
+        /** Stable handle for `details` or `trace`. */
+        id: string;
+        /** The symbol's qualified name when available. */
+        name: string;
+        /** Its declaration kind (`class`, `interface`, `function`, ...). */
+        kind: string;
+        /** Project-relative path of the file that declares it. */
+        file: string;
+        /** 1-based declaration line, when known. */
+        line?: number;
+    }
+    /** A high-dependency symbol with its non-structural fan-in and fan-out. */
+    interface IHotspot extends INode {
+        /** Non-structural edges pointing at this symbol. */
+        fanIn: number;
+        /** Non-structural edges leaving this symbol. */
+        fanOut: number;
+    }
+    /**
+     * One symbol on the project's exported public API surface. The list is ranked
+     * by how depended-on the symbol is, with test, typings, and generated files
+     * excluded.
+     */
+    type IPublicApi = INode;
+}