@g3nomaly/analyze 0.1.3 → 0.1.4

package/dist/model/index.d.ts

@@ -628,6 +628,16 @@ export type EntryNode = SymbolNode | TermNode | DecisionNode | OperationNode | D
  * @param node - Node to test.
  */
 export declare function isSymbolNode(node: GraphNode): node is SymbolNode;
+/**
+ * @brief Tells a placeholder from the others: a type the scanner inferred from members defined outside it, such
+ * as the class around `Registry::run` in a C++ source file.
+ *
+ * It groups those members on the page of their file and declares nothing of its own, so search, `list` and lookup
+ * by name leave it out, and the real declaration answers for the type.
+ *
+ * @param node - Node to test.
+ */
+export declare function isPlaceholderNode(node: GraphNode): boolean;
 /**
  * Tells an entry node, a symbol included, from the others.
  *
@@ -699,6 +709,20 @@ export interface SemanticIndex {
     readonly words: string;
     readonly nodeWords: readonly (readonly [name: readonly number[], text: readonly number[]])[];
 }
+/**
+ * @brief The communities of a bundle: groups of nodes that link to each other more than to the rest, found once
+ * per scan by `detectCommunities` in `scanner/graph/communities.ts`.
+ *
+ * A community is a plain value of a node. Nothing in the layout of the graph page pulls a community together.
+ *
+ * @property labels - Label of each community, by id: the name of its best-linked node. Id 0 is the largest community.
+ * @property of - Community id of each node, by `NodeRef`. A parameter or field has the id of the entry it belongs
+ *   to. `-1` for a section, folder or package, which belong to none.
+ */
+export interface CommunityIndex {
+    readonly labels: readonly string[];
+    readonly of: readonly number[];
+}
 /**
  * @brief The data contract between the scanner and the web app: the CLI serializes
  * one bundle into the generated HTML file, and the app reads it back.
@@ -713,12 +737,14 @@ export interface SemanticIndex {
  * @property nodes - Every node. A node comes after its parent, and siblings are in display order.
  * @property edges - Relations other than `parent`.
  * @property semantic - Index for search by meaning. Left out when the site was generated without embeddings.
+ * @property communities - Community of every node. Left out by a bundle written before communities existed.
  */
 export interface DocsBundle {
     readonly meta: BundleMeta;
     readonly nodes: readonly GraphNode[];
     readonly edges: readonly Edge[];
     readonly semantic?: SemanticIndex;
+    readonly communities?: CommunityIndex;
 }
 /**
  * Where a node is shown: a page, and for an entry an anchor on that page.

package/dist/model/registry.d.ts

@@ -503,6 +503,11 @@ export declare const RELATION_FAMILY_REGISTRY: {
         readonly description: 'What a task names, and what it waits for.';
         readonly colorToken: '--edge-task';
     };
+    readonly code: {
+        readonly label: 'code';
+        readonly description: 'What a source file includes, and what a function calls.';
+        readonly colorToken: '--edge-code';
+    };
 };
 /** Every relation kind other than `parent`, in the order the site lists them. */
 export declare const RELATION_KIND_REGISTRY: {
@@ -619,6 +624,25 @@ export declare const RELATION_KIND_REGISTRY: {
         readonly family: 'task';
         readonly dashed: true;
     };
+    readonly imports: {
+        readonly label: 'imports';
+        readonly description: 'A source file includes or imports that source file.';
+        readonly forward: 'imports';
+        readonly backward: 'is imported by';
+        readonly from: 'source file';
+        readonly to: 'source file';
+        readonly family: 'code';
+    };
+    readonly calls: {
+        readonly label: 'calls';
+        readonly description: 'A function or method calls that function or method.';
+        readonly forward: 'calls';
+        readonly backward: 'is called by';
+        readonly from: 'function or method';
+        readonly to: 'function or method';
+        readonly family: 'code';
+        readonly dashed: true;
+    };
 };
 /** Slug of a top-level section, such as `code`. */
 export type Section = keyof typeof SECTION_REGISTRY;

package/dist/query/graph-view.d.ts

@@ -0,0 +1,105 @@
+import { type EdgeKind, type NodeRef, type NodeType, type Section } from '../model';
+import { type Graph } from './graph';
+/**
+ * How much of the bundle the graph view draws.
+ * - `files`: sections, folders, packages and files, plans and phases. References between entries are drawn between their files.
+ * - `entries`: `files`, plus every class, function, glossary term, decision, table, query and task.
+ * - `all`: `entries`, plus every operation and definition, and each parameter and field that refers to a type of the repository.
+ */
+export declare const GRAPH_LEVELS: readonly ['files', 'entries', 'all'];
+/** One of `GRAPH_LEVELS`. */
+export type GraphLevel = (typeof GRAPH_LEVELS)[number];
+/**
+ * @brief One dot of the graph view.
+ *
+ * @property ref - The node of the bundle the dot stands for.
+ * @property kind - Kind of that node.
+ * @property name - Name of the node, shown as the label of the dot.
+ * @property section - Section the dot is in.
+ * @property parent - Index of the parent dot in `GraphView.nodes`, or `null` for a section.
+ * @property package - Display path of the package the node is or is in, such as `packages/core`, or `null` outside every package.
+ * @property community - Id of the community of the node, or `null` for a section, folder or package.
+ */
+export interface ViewNode {
+    readonly ref: NodeRef;
+    readonly kind: NodeType;
+    readonly name: string;
+    readonly section: Section;
+    readonly parent: number | null;
+    readonly package: string | null;
+    readonly community: number | null;
+}
+/**
+ * @brief One arrow of the graph view, between two dots.
+ *
+ * @property source - Index of the dot the arrow starts at, in `GraphView.nodes`.
+ * @property target - Index of the dot the arrow points at, in `GraphView.nodes`.
+ * @property kind - Kind of the references the arrow stands for.
+ * @property count - Number of edges of the bundle the arrow stands for.
+ */
+export interface ViewReference {
+    readonly source: number;
+    readonly target: number;
+    readonly kind: EdgeKind;
+    readonly count: number;
+}
+/**
+ * @brief The dots and arrows of one level, and which dot shows each node of the bundle.
+ *
+ * A parent precedes its children, as in the bundle. Built by `buildGraphView`
+ * for the graph page, and read by `GraphCanvas`, the graph details panel and
+ * the force layout in `force-graph.ts`.
+ *
+ * @property level - Level the view was built for.
+ * @property nodes - Dots, parents before children.
+ * @property references - Arrows between the dots.
+ * @property shownBy - Bundle node to the index of the dot that shows it.
+ */
+export declare class GraphView {
+    readonly level: GraphLevel;
+    readonly nodes: readonly ViewNode[];
+    readonly references: readonly ViewReference[];
+    private readonly shownBy;
+    /**
+     * @brief Holds the dots, the arrows and the map from bundle nodes to dots.
+     *
+     * @param level - Level the view was built for.
+     * @param nodes - Dots, parents before children.
+     * @param references - Arrows between the dots.
+     * @param shownBy - Bundle node to the index of the dot that shows it.
+     */
+    constructor(level: GraphLevel, nodes: readonly ViewNode[], references: readonly ViewReference[], shownBy: ReadonlyMap<NodeRef, number>);
+    /**
+     * @brief Finds the dot that shows a node of the bundle: its own dot, or the dot
+     * of its nearest drawn ancestor, such as the function of a parameter.
+     *
+     * @param ref - Bundle node to locate.
+     * @returns Index of the dot in `GraphView.nodes`, or `undefined` when no dot shows the node.
+     */
+    locate(ref: NodeRef): number | undefined;
+}
+/**
+ * @brief Builds the view of one level.
+ *
+ * A node the level does not draw, such as a parameter below `all`, is shown by its nearest drawn ancestor:
+ * its edges start or end there. A package has one `package` node, in the code section. A folder of the docs
+ * section at the path of a package is in that package too.
+ *
+ * @param graph - Graph to draw.
+ * @param level - Level to build.
+ * @returns The dots and arrows of the level.
+ */
+export declare function buildGraphView(graph: Graph, level: GraphLevel): GraphView;
+/**
+ * @brief Picks the level the view opens at: every entry while the graph stays readable, files otherwise.
+ *
+ * @param graph - Graph to draw.
+ * @returns `entries` while at most `ENTRIES_LIMIT` dots would be drawn, else `files`.
+ */
+export declare function defaultGraphLevel(graph: Graph): GraphLevel;
+/**
+ * @brief Lists the packages of a graph.
+ *
+ * @returns Display paths of the packages, such as `packages/core`, each once, sorted.
+ */
+export declare function packagesIn(graph: Graph): string[];

package/dist/query/graph.d.ts

@@ -5,6 +5,18 @@ import { type BundleMeta, type DocsBundle, type Edge, type GraphNode, type NodeT
  * @param kind - Kind of a node, such as `parameter`.
  */
 export declare function isDeclarationKind(kind: NodeType): kind is 'parameter' | 'field';
+/**
+ * @brief One community of a bundle.
+ *
+ * @property id - Id of the community. 0 is the largest.
+ * @property label - Name of its best-linked node.
+ * @property size - Number of pages and entries in it. Parameters and fields count with their entry.
+ */
+export interface Community {
+    readonly id: number;
+    readonly label: string;
+    readonly size: number;
+}
 /**
  * @brief The bundle as a graph the app can walk: children, routes and edges in both
  * directions. Built once at startup.
@@ -20,6 +32,7 @@ export declare function isDeclarationKind(kind: NodeType): kind is 'parameter' |
  * @property meta - Title, generation time and generator of the bundle.
  * @property semantic - The embedding model and node vectors for search by meaning, when the bundle has them.
  * @property sections - The sections of the bundle, in display order. Some bundles lack `database`, so a walk over every section goes through this list.
+ * @property communities - The communities of the bundle, by id. Empty for a bundle written before communities existed.
  */
 export declare class Graph {
     readonly meta: BundleMeta;
@@ -35,12 +48,21 @@ export declare class Graph {
         readonly slug: Section;
         readonly node: NodeRef;
     }[];
+    readonly communities: readonly Community[];
+    private readonly communityIndex;
     /**
      * Indexes the nodes and edges of a bundle.
      *
      * @param bundle - Bundle to index, from the embedded data or a loaded file.
      */
     constructor(bundle: DocsBundle);
+    /**
+     * @brief The community a node is in.
+     *
+     * @param ref - Index of the node in the bundle.
+     * @returns The id of its community, or `null` for a section, folder or package, and in a bundle without communities.
+     */
+    communityOf(ref: NodeRef): number | null;
     /**
      * Returns the node at `ref`, and throws when there is none.
      *

package/dist/query/index.d.ts

@@ -1,4 +1,5 @@
-export { Graph, isDeclarationKind } from './graph';
+export { type Community, Graph, isDeclarationKind } from './graph';
 export { buildSearchIndex, type SearchEntry, type SearchMatch, search } from './name-search';
-export { embeddingModelName, type MeaningOptions, searchByMeaning, similarNodes } from './semantic';
+export { embeddingModelName, type MeaningOptions, searchByMeaning, searchWeakMeaning, similarNodes } from './semantic';
 export { codeText, firstParagraph, plainText } from './text';
+export { buildGraphView, defaultGraphLevel, GRAPH_LEVELS, type GraphLevel, GraphView, packagesIn, type ViewNode, type ViewReference, } from './graph-view';

package/dist/query/name-search.d.ts

@@ -41,7 +41,7 @@ export interface SearchMatch {
  * @brief Builds the index for search by words: one entry per file, symbol, glossary term, decision, table,
  * query and task.
  *
- * Folders are not searched. The name and the text of a parameter, field, operation or definition are added to
+ * Folders and placeholders are not searched. The name and the text of a parameter, field, operation or definition are added to
  * the entry of the nearest ancestor that is none of these, such as its function or its file, so a search for
  * it finds that node. It also gets an entry of its own, marked `member`, for a query that keeps to its kind.
  *

package/dist/query/semantic.d.ts

@@ -21,6 +21,16 @@ export interface MeaningOptions {
  * @returns The closest nodes, best first. Empty for a graph without embeddings.
  */
 export declare function searchByMeaning(graph: Graph, query: string, exclude: ReadonlySet<NodeRef>, options?: MeaningOptions): SemanticHit[];
+/**
+ * @brief Finds the nodes closest to a query that score below the cut-off of {@link searchByMeaning}, for a search
+ * that found nothing above it. They may still be what the reader means, worded otherwise.
+ *
+ * @param graph - Graph to search.
+ * @param query - What the reader typed.
+ * @param accepts - Says which nodes count.
+ * @returns Up to `WEAK_LIMIT` hits that score from `WEAK_MIN_SCORE` up to the cut-off, best first. Empty for a graph without embeddings.
+ */
+export declare function searchWeakMeaning(graph: Graph, query: string, accepts: (node: NodeRef) => boolean): SemanticHit[];
 /**
  * Finds the nodes whose meaning is closest to that of a node.
  *

package/dist/retrieval/filter.d.ts

@@ -5,10 +5,13 @@ import type { Graph } from '../query';
  *
  * @property kinds - Kinds to match, such as `function` or `field`. Empty matches every kind. A member kind matches its nodes, and the query returns the node each belongs to.
  * @property section - Section the results are in. `null` looks in every section.
+ * @property communities - Ids of the communities the results are in. Absent or empty looks in every community. A
+ *   section, folder or package is in none, so a filter with communities leaves them out.
  */
 export interface NodeFilter {
     readonly kinds: readonly NodeKind[];
     readonly section: Section | null;
+    readonly communities?: readonly number[];
 }
 /** The filter that keeps every node. */
 export declare const NO_FILTER: NodeFilter;
@@ -24,7 +27,7 @@ export declare function resultOf(graph: Graph, node: NodeRef): NodeRef;
 /**
  * @brief Turns a filter into a test for one node that a query matches against.
  *
- * @returns A function that says whether a node matches. A section never matches. A member node matches by its own kind and by the section of its result.
+ * @returns A function that says whether a node matches. A section and a placeholder never match. A member node matches by its own kind and by the section of its result.
  */
 export declare function nodeTest(graph: Graph, filter: NodeFilter): (node: NodeRef) => boolean;
 /**

package/dist/retrieval/graph-export.d.ts

@@ -0,0 +1,82 @@
+import { type EdgeKind, type NodeKind, type NodeType } from '../model';
+import { type Graph } from '../query';
+import type { NodeFilter } from './filter';
+/**
+ * How much of the bundle an export holds.
+ * - `packages`: one node per package, and the edges between packages, each the sum of the edges between their nodes.
+ * - `communities`: one node per community, and the edges between communities, summed the same way.
+ * - `files`, `entries` and `all`: the levels of the graph page of the site, see `GRAPH_LEVELS`.
+ */
+export declare const EXPORT_LEVELS: readonly ["packages", "communities", "files", "entries", "all"];
+/** One of {@link EXPORT_LEVELS}. */
+export type ExportLevel = (typeof EXPORT_LEVELS)[number];
+/**
+ * @brief What to export: the level, which nodes and which edges.
+ *
+ * @property level - How much of the bundle the export holds.
+ * @property filter - Kinds and section of the nodes to keep. An edge is kept when both its ends are.
+ * @property edges - Edge kinds to keep. Empty keeps every kind.
+ */
+export interface GraphExportOptions {
+    readonly level: ExportLevel;
+    readonly filter: NodeFilter;
+    readonly edges: readonly EdgeKind[];
+}
+/**
+ * @brief One node of an export.
+ *
+ * @property id - Id of the node, as `show` and `refs` take it.
+ * @property kind - Kind of the node, such as `package`, `file` or `function`.
+ * @property type - Type of the node, such as `source` or `method`.
+ * @property name - Name of the node. For a package, the name its manifest gives.
+ * @property package - Display path of the package the node is or is in, such as `libs/slam`, or `null`.
+ * @property community - Id of the community of the node, or `null` for a section, folder or package.
+ * @property parent - Id of the node it is drawn in, such as the folder of a file, or `null`. Always `null` at the
+ *   `packages` and `communities` levels.
+ */
+export interface ExportNode {
+    readonly id: string;
+    readonly kind: NodeKind | 'community';
+    readonly type: NodeType | 'community';
+    readonly name: string;
+    readonly package: string | null;
+    readonly community: number | null;
+    readonly parent: string | null;
+}
+/**
+ * @brief Edges of one kind between two nodes of an export.
+ *
+ * An edge of a node the level does not hold, such as a call between two functions at the `files` level, counts
+ * for the nodes that hold its ends, such as their files.
+ *
+ * @property from - Id of the node the edges start at.
+ * @property kind - Kind of the edges.
+ * @property to - Id of the node the edges point at.
+ * @property count - Number of edges of the bundle this one stands for.
+ */
+export interface ExportEdge {
+    readonly from: string;
+    readonly kind: EdgeKind;
+    readonly to: string;
+    readonly count: number;
+}
+/**
+ * @brief The nodes and edges of one level of a bundle, with ids instead of refs.
+ *
+ * @property level - The level exported.
+ * @property nodes - The nodes, in the order of the navigation.
+ * @property edges - The edges, sorted by source, kind and target.
+ */
+export interface GraphExport {
+    readonly level: ExportLevel;
+    readonly nodes: readonly ExportNode[];
+    readonly edges: readonly ExportEdge[];
+}
+/**
+ * @brief Exports one level of a graph.
+ *
+ * @param graph - Graph of the bundle.
+ * @param options - Level, node filter and edge kinds.
+ * @returns The nodes and edges of the level.
+ */
+export declare function exportGraph(graph: Graph, options: GraphExportOptions): GraphExport;

package/dist/retrieval/index.d.ts

@@ -1,5 +1,6 @@
 export { ALL_REFERENCES, describeNode, type ReferenceOptions, referencesOf } from './describe';
 export { NO_FILTER, type NodeFilter, nodeTest, resultOf, resultsOf } from './filter';
+export { EXPORT_LEVELS, type ExportEdge, type ExportLevel, type ExportNode, type GraphExport, type GraphExportOptions, exportGraph, } from './graph-export';
 export { codeBlock, htmlToMarkdown } from './markdown';
 export type { ContentReport, DatabaseObjectReport, DeclarationReport, ForeignKeyReport, NodeReport, NodeSummary, OperationReport, QueryReport, Reference, References, TableReport, TagReport, TaskReport, } from './report';
 export { type Resolution, resolveNode } from './resolve';

package/dist/retrieval/retriever.d.ts

@@ -2,6 +2,7 @@ import type { NodeRef } from '../model';
 import { type Graph } from '../query';
 import { type ReferenceOptions } from './describe';
 import { type NodeFilter } from './filter';
+import { type GraphExport, type GraphExportOptions } from './graph-export';
 import type { NodeReport, NodeSummary, References } from './report';
 import { type Resolution } from './resolve';
 /** The search modes a caller can pick from, the default first. */
@@ -25,17 +26,19 @@ export interface SearchOptions {
  *
  * @property match - `name`: every word of the query is in the name or the path of the node. `text`: at least one word is only in its description. `meaning`: the node is close to the query in the embedding model.
  * @property score - From 0 to 1 for a match by meaning. `null` for a match by words.
+ * @property weak - `true` for a match by meaning below the cut-off, which only a search that found nothing else returns. Absent on every other hit.
  */
 export interface SearchHit extends NodeSummary {
     readonly match: 'name' | 'text' | 'meaning';
     readonly score: number | null;
+    readonly weak?: true;
 }
 /**
- * @brief Answers queries on one bundle: search, list, look up, describe.
+ * @brief Answers queries on one bundle: search, list, look up, describe, export.
  *
  * Holds the graph of the bundle and, after the first search by name, the
  * search index. `openRetriever` in `api/source.ts` creates one per request from
- * a `Graph`; `listIn`, `searchIn`, `showIn` and `refsIn` in `api/` each call one
+ * a `Graph`; `listIn`, `searchIn`, `showIn`, `refsIn` and `graphIn` in `api/` each call one
  * method. Create one with `new Retriever(new Graph(bundle))`. Every answer is
  * plain data with ids, so a caller can print it, serialize it or feed an id into
  * the next call.
@@ -64,6 +67,15 @@ export declare class Retriever {
      * @returns The hits, each once.
      */
     search(query: string, options: SearchOptions): SearchHit[];
+    /**
+     * @brief Finds the few nodes closest in meaning to a query below the cut-off of `search`, for a search that found
+     * nothing. The caller shows them as weak matches.
+     *
+     * @param query - The query that found nothing.
+     * @param options - Mode and filter of that search. Its limit caps the hits too.
+     * @returns The hits, best first, each with `weak: true`. Empty for a search by name or a bundle without embeddings.
+     */
+    searchWeak(query: string, options: SearchOptions): SearchHit[];
     /**
      * @brief Lists pages and entries in display order.
      *
@@ -102,4 +114,11 @@ export declare class Retriever {
      * @returns What the node links to and what links to it.
      */
     references(node: NodeRef, options?: ReferenceOptions): References;
+    /**
+     * @brief Exports one level of the bundle as nodes and edges.
+     *
+     * @param options - Level, node filter and edge kinds.
+     * @returns The nodes and edges of the level, with ids.
+     */
+    exportGraph(options: GraphExportOptions): GraphExport;
 }

package/dist/scanner/code/calls.d.ts

@@ -0,0 +1,136 @@
+import type { Node } from 'web-tree-sitter';
+import type { NodeRef } from '../../model';
+import type { GraphBuilder } from '../graph/builder';
+import type { SourceFileIndex } from './imports';
+import { type CallableIndex, type TypeIndex, type TypeScope } from './types';
+/**
+ * @brief How a call names what it calls.
+ *
+ * - `bare`: by name alone, as in `helper()`.
+ * - `scoped`: through a namespace or a type, as in `geo::distance()` or `Timer::once()`.
+ * - `self`: through the instance it runs on, as in `this->flush()` or `self.flush()`.
+ * - `member`: through another value, as in `store.flush()` or `store->flush()`.
+ */
+export type CallVia = 'bare' | 'scoped' | 'self' | 'member';
+/**
+ * @brief One call in the body of a function, as written.
+ *
+ * @property name - Name of the function the call names, such as `flush`.
+ * @property via - How the call names it.
+ * @property qualifier - For a `scoped` call, the names in front of `name`, outermost first, such as `['geo']`.
+ *   For a `member` call, the variable it goes through, such as `['store']`, or `[]` when that is an expression.
+ */
+export interface RawCall {
+    readonly name: string;
+    readonly via: CallVia;
+    readonly qualifier: readonly string[];
+}
+/**
+ * @brief Reads every call in a function body, each once, in the order they first appear.
+ *
+ * Calls inside a nested definition belong to that definition and are left out. Calls inside a lambda or a
+ * closure belong to the function around it. A call through a variable the body declares itself keeps no
+ * variable, since that local may hide a parameter or field of the same name and its type is unknown.
+ *
+ * @param body - Body node of the function.
+ * @param definitions - Ids of the definition nodes of the file.
+ * @returns The calls the body makes.
+ */
+export declare function readCalls(body: Node, definitions: ReadonlySet<number>): RawCall[];
+/**
+ * @brief What a call can be resolved with: where it is, the names around its function, and the declared types
+ * of the variables it can go through.
+ *
+ * @property scope - Where the call is.
+ * @property owners - Names of the namespaces and types around the calling function, outermost first.
+ * @property variables - Declared type of each parameter of the calling function and each field of its type, by name.
+ * @property inType - Whether the innermost owner is a type rather than a namespace.
+ * @property implicitReceiver - Whether a bare call in a method can mean another method of its type, from the spec.
+ */
+export interface CallContext {
+    readonly scope: TypeScope;
+    readonly owners: readonly string[];
+    readonly variables: ReadonlyMap<string, string>;
+    readonly inType: boolean;
+    readonly implicitReceiver: boolean;
+}
+/**
+ * @brief Turns the calls of a function into `calls` edges to the functions of the scan they reach.
+ *
+ * A call only links when it names one function its file sees: one in the same file or in a file it imports, directly
+ * or not. For a language whose imports the scan does not read, a bare call only reaches a free function of the same
+ * directory. A bare call reaches a function of the calling type where the language allows it, else a free function. A scoped call reaches a member of the namespace or type it names. A member call reaches a method of
+ * the declared type of the parameter or field it goes through, else a static method of a type of that name; a call
+ * through any other expression links nowhere, since its type is unknown.
+ *
+ * Holds the indexes it resolves against, the graph it adds edges to, and the fields of each type. Created per scan
+ * by `RepositoryScanner` in `scanner/scanner.ts`; `SymbolPlanner` in `symbols.ts` registers the fields of each type
+ * and links the calls of each function once every declaration is known.
+ *
+ * @example
+ * const calls = new CallLinker(types, callables, sources, graph);
+ * calls.link(functionRef, rawSymbol.calls, { scope, owners: ['geo'], variables: new Map() });
+ */
+export declare class CallLinker {
+    private readonly types;
+    private readonly callables;
+    private readonly sources;
+    private readonly graph;
+    private readonly fields;
+    /**
+     * Takes the indexes the calls resolve against and the graph the edges are added to.
+     *
+     * @param types - Type declarations, for the type of a variable and the owner of a method.
+     * @param callables - Functions and methods the calls reach.
+     * @param sources - Source files with their imports, to tell which files a call can reach.
+     * @param graph - Graph the edges are added to.
+     */
+    constructor(types: TypeIndex, callables: CallableIndex, sources: SourceFileIndex, graph: GraphBuilder);
+    /**
+     * @brief Records the declared types of the fields of a type, for the calls of its methods.
+     *
+     * @param type - Node of the type.
+     * @param fields - Declared type of each field, by name.
+     */
+    registerFields(type: NodeRef, fields: ReadonlyMap<string, string>): void;
+    /**
+     * @brief The declared types of the fields of the type a function belongs to, even when the function is defined
+     * outside it, as a C++ method in its source file is.
+     *
+     * @param context - Where the function is.
+     * @returns The field types by name, empty when the function belongs to no type of the scan.
+     */
+    fieldsAround(context: Pick<CallContext, 'scope' | 'owners'>): ReadonlyMap<string, string>;
+    /**
+     * @brief Records a `calls` edge from `from` to each function its calls reach.
+     *
+     * @param from - Node of the calling function.
+     * @param calls - The calls in its body.
+     * @param context - Where the function is.
+     */
+    link(from: NodeRef, calls: readonly RawCall[], context: CallContext): void;
+    /**
+     * @brief The function one call reaches.
+     *
+     * @param call - The call.
+     * @param context - Where the calling function is.
+     * @returns The function, or `null` when the call reaches none or more than one.
+     */
+    private resolve;
+    /**
+     * @brief Where a bare call looks for a free function. A file whose imports the scan does not read only sees its
+     * own directory, so a common name never reaches across the repository.
+     *
+     * @param scope - Where the call is.
+     * @returns The same scope, limited to the directory of the file when its imports are unknown.
+     */
+    private freeFunctionScope;
+    /**
+     * @brief The method a call through a variable reaches, from the declared type of that variable.
+     *
+     * @param call - A `member` call.
+     * @param context - Where the calling function is.
+     * @returns The method, or `null` when the type of the variable is unknown or names no single method.
+     */
+    private resolveMember;
+}

package/dist/scanner/code/extract.d.ts

@@ -1,5 +1,7 @@
 import { type SymbolKind } from '../../model';
 import type { Node, Query } from 'web-tree-sitter';
+import { type RawCall } from './calls';
+import type { ImportRequest } from './imports';
 import type { LanguageSpec } from './language';
 /**
  * One parameter as declared.
@@ -51,6 +53,8 @@ export interface RawField {
  * @property isStatic - True for a method called on its type rather than on an instance.
  * @property returnsValue - True when a call to the symbol yields a value.
  * @property inferred - True for an owner type that is not declared in this file.
+ * @property internal - True for a function only its own file can call, as the spec's `isInternal` decides.
+ * @property calls - For a function or method: the calls in its body, each once.
  * @property children - Members nested under this symbol.
  */
 export interface RawSymbol {
@@ -71,17 +75,21 @@ export interface RawSymbol {
     isStatic: boolean;
     returnsValue: boolean;
     readonly inferred: boolean;
+    readonly internal: boolean;
+    readonly calls: readonly RawCall[];
     readonly children: RawSymbol[];
 }
 /**
- * Symbols and package name extracted from one source file.
+ * Symbols, package name and imports extracted from one source file.
  *
  * @property symbols - Top-level symbols of the file, each with its members nested under it.
  * @property packageName - Package or namespace the file declares, or `null` when the language has none.
+ * @property imports - The files the file imports, as it writes them. Empty for a language without `imports`.
  */
 export interface ExtractedFile {
     readonly symbols: RawSymbol[];
     readonly packageName: string | null;
+    readonly imports: readonly ImportRequest[];
 }
 /**
  * @brief Turns a parsed file into a tree of {@link RawSymbol}s, driven by a {@link LanguageSpec}.
@@ -98,7 +106,7 @@ export declare class SymbolExtractor {
      * @param query - Compiled tags query of the language.
      * @param spec - Language spec that drives the extraction.
      * @param source - Full text of the file the tree was parsed from; node offsets index into it.
-     * @returns Symbols of the file and its declared package name.
+     * @returns Symbols of the file, its declared package name and its imports.
      */
     extract(root: Node, query: Query, spec: LanguageSpec, source: string): ExtractedFile;
     /**