@ttsc/graph 0.16.4 → 0.16.6

package/src/server/runTrace.ts

@@ -0,0 +1,359 @@
+import { TtscGraphMemory } from "../model/TtscGraphMemory";
+import { ITtscGraphEvidence } from "../structures/ITtscGraphEvidence";
+import { ITtscGraphNode } from "../structures/ITtscGraphNode";
+import { ITtscGraphTrace } from "../structures/ITtscGraphTrace";
+import { accessAliasesFor } from "./accessAliases";
+import { resolveGraphHandle } from "./resolveHandle";
+import { edgeEvidenceOf, edgeEvidenceTextOf, signatureOf } from "./runDetails";
+
+const DEFAULT_DEPTH = 2;
+const DEFAULT_MAX_NODES = 6;
+const MAX_OPEN_DEPTH = 2;
+const MAX_OPEN_NODES = 8;
+const MAX_HOPS_PER_NODE = 1;
+const MAX_STEPS = 6;
+const MAX_NEXT_HANDLES = 2;
+
+/**
+ * Breadth-first trace along the dependency graph. Structural
+ * (contains/exports/imports) edges are excluded so the path is real call/type
+ * flow; forward walks callees, reverse and impact walk callers. Impact
+ * additionally tags each reached node's role so the blast radius on the public
+ * surface is legible.
+ */
+export function runTrace(
+  graph: TtscGraphMemory,
+  props: ITtscGraphTrace.IRequest,
+): ITtscGraphTrace {
+  const direction = props.direction ?? "forward";
+  const focus = props.focus ?? "all";
+  const maxDepth = bound(props.maxDepth, DEFAULT_DEPTH, 1, MAX_OPEN_DEPTH);
+  const maxNodes = bound(props.maxNodes, DEFAULT_MAX_NODES, 1, MAX_OPEN_NODES);
+  const maxHops = maxNodes * MAX_HOPS_PER_NODE;
+  const reverse = direction === "reverse" || direction === "impact";
+  // Only an impact trace tags reached nodes with their public-surface role; for
+  // forward/reverse the role is noise.
+  const withRoles = direction === "impact";
+
+  const start = resolveGraphHandle(graph, props.from);
+  if (start.candidates) {
+    return {
+      type: "trace",
+      direction,
+      hops: [],
+      reached: [],
+      truncated: false,
+      candidates: start.candidates.map((n) => summary(graph, n)),
+    };
+  }
+  if (start.node === undefined) {
+    return {
+      type: "trace",
+      direction,
+      hops: [],
+      reached: [],
+      truncated: false,
+    };
+  }
+
+  // Path mode: with `to`, return the dependency path from `from` to `to`, the
+  // one-call answer for "how does A reach B", instead of an open-ended trace.
+  if (props.to !== undefined && props.to !== "") {
+    const base = {
+      type: "trace" as const,
+      direction: "path",
+      hops: [],
+      reached: [],
+      truncated: false,
+    };
+    const target = resolveGraphHandle(graph, props.to);
+    if (target.candidates) {
+      return {
+        ...base,
+        start: summary(graph, start.node),
+        candidates: target.candidates.map((n) => summary(graph, n)),
+      };
+    }
+    if (target.node === undefined) {
+      return { ...base, start: summary(graph, start.node) };
+    }
+    const found = findPath(
+      graph,
+      start.node.id,
+      target.node.id,
+      bound(props.maxDepth, 12, 1, 12),
+      focus,
+    );
+    const path = found?.path ?? [];
+    const hops = found?.hops ?? [];
+    return {
+      ...base,
+      start: summary(graph, start.node),
+      target: summary(graph, target.node),
+      hops,
+      path: path.map((node, i) => summary(graph, node, i, false, true)),
+      steps: traceSteps(graph, hops),
+      next: nextFromPath(path),
+    };
+  }
+
+  const hops: ITtscGraphTrace.IHop[] = [];
+  const reached = new Map<string, ITtscGraphTrace.INode>();
+  const visited = new Set<string>([start.node.id]);
+  let queue: Array<{ id: string; depth: number }> = [
+    { id: start.node.id, depth: 0 },
+  ];
+  let truncated = false;
+
+  while (queue.length > 0) {
+    const next: Array<{ id: string; depth: number }> = [];
+    for (const { id, depth } of queue) {
+      if (depth >= maxDepth) {
+        truncated = true;
+        continue;
+      }
+      const edges = reverse ? graph.incoming(id) : graph.outgoing(id);
+      for (const edge of edges) {
+        if (!traversable(edge.kind, focus)) continue;
+        const otherId = reverse ? edge.from : edge.to;
+        const other = graph.node(otherId);
+        if (other === undefined || other.kind === "file") continue;
+        const hop: ITtscGraphTrace.IHop = {
+          from: edge.from,
+          to: edge.to,
+          kind: edge.kind,
+          depth: depth + 1,
+        };
+        const evidence = edgeEvidenceOf(edge);
+        if (evidence !== undefined) hop.evidence = evidence;
+        const aliases = accessAliasesFor(
+          graph.node(edge.to),
+          edgeEvidenceTextOf(edge),
+        );
+        if (aliases !== undefined) hop.aliases = aliases;
+        // A back-edge to the start or an already-reached node: record the hop;
+        // its endpoints are already represented.
+        if (visited.has(otherId)) {
+          if (hops.length >= maxHops) truncated = true;
+          else hops.push(hop);
+          continue;
+        }
+        // A new node past the cap is left unrepresented, so drop its hop too:
+        // every hop's endpoints stay resolvable in `reached`/`start`.
+        if (reached.size >= maxNodes) {
+          truncated = true;
+          continue;
+        }
+        if (hops.length >= maxHops) {
+          truncated = true;
+          continue;
+        }
+        visited.add(otherId);
+        reached.set(otherId, summary(graph, other, depth + 1, withRoles));
+        next.push({ id: otherId, depth: depth + 1 });
+        hops.push(hop);
+      }
+    }
+    queue = next;
+  }
+
+  return {
+    type: "trace",
+    start: summary(graph, start.node),
+    direction,
+    hops,
+    reached: [...reached.values()],
+    steps: traceSteps(graph, hops),
+    next: {
+      details: [start.node.id, ...reached.keys()].slice(0, MAX_NEXT_HANDLES),
+      traceFrom: [...reached.keys()].slice(0, MAX_NEXT_HANDLES),
+    },
+    truncated,
+  };
+}
+
+function nextFromPath(path: ITtscGraphNode[]): ITtscGraphTrace.INext {
+  return {
+    details: path.map((node) => node.id),
+    traceFrom: path.length > 0 ? [path[path.length - 1]!.id] : [],
+  };
+}
+
+function traceSteps(
+  graph: TtscGraphMemory,
+  hops: ITtscGraphTrace.IHop[],
+): string[] {
+  return hops.slice(0, MAX_STEPS).map((hop) => {
+    const from = graph.node(hop.from);
+    const to = graph.node(hop.to);
+    const lhs = from?.qualifiedName ?? from?.name ?? hop.from;
+    const rhs = to?.qualifiedName ?? to?.name ?? hop.to;
+    const evidence =
+      hop.evidence === undefined
+        ? ""
+        : ` at ${hop.evidence.file}:${hop.evidence.startLine}`;
+    const aliases =
+      hop.aliases === undefined ? "" : ` aliases ${hop.aliases.join(", ")}`;
+    return `${lhs} -[${hop.kind}${evidence}${aliases}]-> ${rhs}`;
+  });
+}
+
+/**
+ * The shortest dependency path from `startId` to `targetId` over real (non-
+ * structural) forward edges, breadth-first, or null when `targetId` is not
+ * reachable within maxDepth. Returns the nodes in order and the hops between.
+ */
+function findPath(
+  graph: TtscGraphMemory,
+  startId: string,
+  targetId: string,
+  maxDepth: number,
+  focus: ITtscGraphTrace.IRequest["focus"],
+): { path: ITtscGraphNode[]; hops: ITtscGraphTrace.IHop[] } | null {
+  const startNode = graph.node(startId);
+  if (startNode === undefined) return null;
+  if (startId === targetId) return { path: [startNode], hops: [] };
+  const parent = new Map<
+    string,
+    {
+      via: string;
+      kind: string;
+      evidence?: ITtscGraphEvidence;
+      evidenceText?: string;
+    }
+  >();
+  const visited = new Set<string>([startId]);
+  let queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }];
+  while (queue.length > 0) {
+    const next: Array<{ id: string; depth: number }> = [];
+    for (const { id, depth } of queue) {
+      if (depth >= maxDepth) continue;
+      for (const edge of graph.outgoing(id)) {
+        if (!traversable(edge.kind, focus)) continue;
+        const otherId = edge.to;
+        if (visited.has(otherId)) continue;
+        const other = graph.node(otherId);
+        if (other === undefined || other.kind === "file") continue;
+        visited.add(otherId);
+        const evidence = edgeEvidenceOf(edge);
+        parent.set(otherId, {
+          via: id,
+          kind: edge.kind,
+          evidence,
+          evidenceText: edgeEvidenceTextOf(edge),
+        });
+        if (otherId === targetId) {
+          const ids: string[] = [otherId];
+          let cur = otherId;
+          while (cur !== startId) {
+            const p = parent.get(cur);
+            if (p === undefined) break;
+            ids.unshift(p.via);
+            cur = p.via;
+          }
+          const path: ITtscGraphNode[] = [];
+          for (const nid of ids) {
+            const n = graph.node(nid);
+            if (n !== undefined) path.push(n);
+          }
+          const hops: ITtscGraphTrace.IHop[] = [];
+          for (let i = 1; i < path.length; i++) {
+            const node = path[i]!;
+            const parentEdge = parent.get(node.id);
+            const hop: ITtscGraphTrace.IHop = {
+              from: path[i - 1]!.id,
+              to: node.id,
+              kind: parentEdge?.kind ?? "calls",
+              depth: i,
+            };
+            if (parentEdge?.evidence !== undefined)
+              hop.evidence = parentEdge.evidence;
+            const aliases = accessAliasesFor(node, parentEdge?.evidenceText);
+            if (aliases !== undefined) hop.aliases = aliases;
+            hops.push(hop);
+          }
+          return { path, hops };
+        }
+        next.push({ id: otherId, depth: depth + 1 });
+      }
+    }
+    queue = next;
+  }
+  return null;
+}
+
+/**
+ * Summarize a node for a trace result. With `withRoles`, tag the public-surface
+ * roles (exported / test) an impact trace reports; other directions omit them.
+ */
+function summary(
+  graph: TtscGraphMemory,
+  node: ITtscGraphNode,
+  depth?: number,
+  withRoles = false,
+  withSignature = false,
+): ITtscGraphTrace.INode {
+  const out: ITtscGraphTrace.INode = {
+    id: node.id,
+    name: node.qualifiedName ?? node.name,
+    kind: node.kind,
+    file: node.file,
+  };
+  if (depth !== undefined) out.depth = depth;
+  if (withSignature) {
+    const sig = signatureOf(graph.project, node);
+    if (sig !== undefined) out.signature = sig;
+  }
+  if (withRoles) {
+    const roles: string[] = [];
+    if (node.exported) roles.push("exported");
+    if (isTestFile(node.file)) roles.push("test");
+    if (roles.length > 0) out.roles = roles;
+  }
+  return out;
+}
+
+/** An edge the trace should follow: a real dependency, not a structural edge. */
+function traversable(
+  kind: string,
+  focus: ITtscGraphTrace.IRequest["focus"],
+): boolean {
+  if (kind === "contains" || kind === "exports" || kind === "imports") {
+    return false;
+  }
+  if (focus === "execution") {
+    return (
+      kind === "calls" ||
+      kind === "instantiates" ||
+      kind === "accesses" ||
+      kind === "renders"
+    );
+  }
+  if (focus === "types") {
+    return (
+      kind === "type_ref" ||
+      kind === "extends" ||
+      kind === "implements" ||
+      kind === "overrides" ||
+      kind === "decorates"
+    );
+  }
+  return true;
+}
+
+function isTestFile(file: string): boolean {
+  return (
+    /(^|\/)(test|tests|__tests__|spec)\//.test(file) ||
+    /\.(test|spec)\.[cm]?tsx?$/.test(file)
+  );
+}
+
+function bound(
+  value: number | undefined,
+  fallback: number,
+  min: number,
+  max: number,
+): number {
+  const n = value === undefined || !Number.isFinite(value) ? fallback : value;
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}

package/src/server/startServer.ts

@@ -0,0 +1,25 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { TtscGraphMemory } from "../model/TtscGraphMemory";
+import { loadGraph } from "../model/loadGraph";
+import { createServer } from "./createServer";
+
+/**
+ * Serve the graph tools over MCP on stdio. The server answers the MCP handshake
+ * immediately and builds the resident graph on the first tool call, so a large
+ * project cannot make the client give up before tools are advertised.
+ */
+export async function startServer(options: {
+  cwd?: string;
+  tsconfig?: string;
+  /** Server version reported in the MCP handshake. */
+  version: string;
+}): Promise<void> {
+  let graph: TtscGraphMemory | undefined;
+  const server = createServer(() => {
+    graph ??= loadGraph({ cwd: options.cwd, tsconfig: options.tsconfig });
+    return graph;
+  }, options.version);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/structures/ITtscGraphApplication.ts

@@ -0,0 +1,116 @@
+import { ITtscGraphDetails } from "./ITtscGraphDetails";
+import { ITtscGraphEntrypoints } from "./ITtscGraphEntrypoints";
+import { ITtscGraphEscape } from "./ITtscGraphEscape";
+import { ITtscGraphLookup } from "./ITtscGraphLookup";
+import { ITtscGraphOverview } from "./ITtscGraphOverview";
+import { ITtscGraphTrace } from "./ITtscGraphTrace";
+
+/**
+ * The MCP tool surface of `@ttsc/graph`, as a typed application.
+ *
+ * The single method is the single MCP tool. Its parameter object becomes the
+ * JSON schema once `typia.llm.controller` reflects this interface.
+ * `TtscGraphApplication` implements it over the resident graph.
+ */
+export interface ITtscGraphApplication {
+  /**
+   * Query the TypeScript project graph for code evidence.
+   *
+   * Use this before answering TypeScript codebase questions. It returns
+   * checker-resolved symbols, dependency paths, edge evidence ranges, and
+   * sourceSpan anchors from the resident graph, avoiding assumptions, shell
+   * search, or file reads when graph evidence is enough.
+   *
+   * Fill properties in order: question, graphNeed, draft, review, request.
+   * Write `draft.reason` before `draft.type`, then choose `entrypoints`,
+   * `lookup`, `trace`, `details`, `overview`, or `escape`.
+   *
+   * Most answers should need 1-3 calls; four is the hard stop for one answer.
+   * Keep slices small, prefer defaults, and stop once file/symbol/range
+   * evidence is enough.
+   *
+   * @param props The reasoning and selected graph request
+   * @returns One `result` union member matching the selected request type
+   */
+  query(props: ITtscGraphApplication.IProps): ITtscGraphApplication.IResult;
+}
+
+export namespace ITtscGraphApplication {
+  /** Think, review, then submit exactly one graph request. */
+  export interface IProps {
+    /**
+     * User's TypeScript code question.
+     *
+     * Restate the codebase question being answered. Keep this about TypeScript
+     * source, symbols, call flow, type flow, or architecture. If the user is
+     * asking about scripts, config, generated output, or documentation instead,
+     * say that boundary here.
+     */
+    question: string;
+
+    /**
+     * Why the resident graph is the next evidence source.
+     *
+     * State what graph evidence is needed and why assumptions or broad shell
+     * search are not the next step for this call. Name the smallest evidence
+     * that would let the agent stop. If graph is not actually the right source,
+     * say that and use `escape`.
+     */
+    graphNeed: string;
+
+    /**
+     * First request-type decision before arguments are filled.
+     *
+     * Explain why one operation class is smaller than the alternatives, then
+     * name it in `draft.type`. This is only the draft; the final arguments are
+     * in `request` after `review`.
+     */
+    draft: IRequestDraft;
+
+    /**
+     * Critical review of the draft request.
+     *
+     * Check whether the draft avoids overfetch, non-graph fallback, broad
+     * reads, and unnecessary neighbor expansion. If this would be a fourth
+     * broad lookup, trace, or details call, prefer answering from evidence in
+     * hand or choose `escape`. Do not spend graph calls only to hunt for tests.
+     * If the draft is wrong, choose the corrected type in `request`.
+     */
+    review: string;
+
+    /** The graph operation chosen from the reasoning above, or a no-op escape. */
+    request:
+      | ITtscGraphEntrypoints.IRequest
+      | ITtscGraphLookup.IRequest
+      | ITtscGraphTrace.IRequest
+      | ITtscGraphDetails.IRequest
+      | ITtscGraphOverview.IRequest
+      | ITtscGraphEscape.IRequest;
+  }
+
+  /** First-pass operation choice before final request arguments. */
+  export interface IRequestDraft {
+    /** Why this operation type is the smallest useful next step. */
+    reason: string;
+
+    /** Draft discriminator for the intended graph operation. */
+    type:
+      | ITtscGraphEntrypoints.IRequest["type"]
+      | ITtscGraphLookup.IRequest["type"]
+      | ITtscGraphTrace.IRequest["type"]
+      | ITtscGraphDetails.IRequest["type"]
+      | ITtscGraphOverview.IRequest["type"]
+      | ITtscGraphEscape.IRequest["type"];
+  }
+
+  /** The selected request's output. `result.type` mirrors `request.type`. */
+  export interface IResult {
+    result:
+      | ITtscGraphEntrypoints
+      | ITtscGraphLookup
+      | ITtscGraphTrace
+      | ITtscGraphDetails
+      | ITtscGraphOverview
+      | ITtscGraphEscape;
+  }
+}

package/src/structures/ITtscGraphDecorator.ts

@@ -0,0 +1,31 @@
+/**
+ * A decorator as written on a declaration, carried on the decorated
+ * {@link ITtscGraphNode}'s `decorators`.
+ *
+ * The graph reports the decorator faithfully rather than interpreting any
+ * framework's convention: the `name` is the decorator as written (`Controller`,
+ * `Get`, `TypedRoute.Get`, ...), and statically resolvable literal arguments
+ * are preserved so a consumer can apply its own meaning without re-parsing
+ * source.
+ */
+export interface ITtscGraphDecorator {
+  /**
+   * The decorator name as written, qualified through its access path:
+   * `Controller`, `Get`, `TypedRoute.Get`, `MessagePattern`.
+   */
+  name: string;
+
+  /** The literal call arguments, in source order. Empty for a bare decorator. */
+  arguments: ITtscGraphDecorator.IArgument[];
+}
+export namespace ITtscGraphDecorator {
+  /**
+   * One argument of an {@link ITtscGraphDecorator}. `literal` is set only when
+   * the argument is a string, number, or boolean literal the producer could
+   * resolve statically, so a consumer can use it without evaluating code.
+   */
+  export interface IArgument {
+    /** The statically-resolved literal value, when the argument is a literal. */
+    literal?: string | number | boolean;
+  }
+}

package/src/structures/ITtscGraphDetails.ts

@@ -0,0 +1,134 @@
+import { ITtscGraphDecorator } from "./ITtscGraphDecorator";
+import { ITtscGraphEvidence } from "./ITtscGraphEvidence";
+
+/**
+ * The resolved symbol details returned for a set of handles.
+ *
+ * The default payload is source-free: signatures, member outlines, and direct
+ * graph summaries with sourceSpan anchors.
+ */
+export interface ITtscGraphDetails {
+  /** Discriminator for selected symbol inspection. */
+  type: "details";
+
+  nodes: ITtscGraphDetails.INode[];
+
+  /** Handles that resolved to no node, or that were ambiguous. */
+  unknown: string[];
+}
+export namespace ITtscGraphDetails {
+  /** Which handles to inspect, and how much of each to return. */
+  export 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; 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` only when the first slice is not enough.
+     *
+     * @default false
+     */
+    neighbors?: boolean;
+
+    /**
+     * Maximum dependencies and dependents to return per side when
+     * `neighbors:true`.
+     *
+     * @default 2
+     */
+    neighborLimit?: number;
+
+    /**
+     * Maximum owned members to return for a container or object literal. Raise
+     * only when the first outline is truncated.
+     *
+     * @default 6
+     */
+    memberLimit?: number;
+
+    /**
+     * Maximum direct execution and type references to return per group. Raise
+     * only when the first dependency slice is not enough.
+     *
+     * @default 1
+     */
+    dependencyLimit?: number;
+  }
+
+  /** One inspected node: its declared shape and graph coordinates. */
+  export interface INode {
+    id: string;
+    name: string;
+    kind: string;
+    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[];
+    /** 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[];
+    /** The declaration or implementation file and line 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. */
+  export interface IMember {
+    name: string;
+    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. */
+  export interface IReference {
+    id: string;
+    name: string;
+    kind: string;
+    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 lets
+     * an agent see why the edge exists without opening the file.
+     */
+    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/src/structures/ITtscGraphDiagnostic.ts

@@ -0,0 +1,34 @@
+/**
+ * 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;
+}