@g3nomaly/analyze 0.1.5 → 0.1.6

package/dist/model/index.d.ts

@@ -281,6 +281,7 @@ export interface SymbolExample {
  *
  * @property anchor - Unique within the file and safe in a URL hash.
  * @property line - Line of the file where the declaration starts.
+ * @property endLine - Line of the file where the declaration ends. Absent in a bundle written before end lines existed.
  * @property signatureHtml - Highlighted declaration head. Empty for a type the scanner inferred from its members.
  * @property modifiers - Keywords in front of the declaration, such as `export`, `static` or `async`.
  * @property annotations - Decorators, attributes and annotations, verbatim.
@@ -292,6 +293,7 @@ export interface SymbolExample {
 export interface SymbolNode extends NodeBase<SymbolKind> {
     readonly anchor: string;
     readonly line: number;
+    readonly endLine?: number;
     readonly signatureHtml: string;
     readonly modifiers: readonly string[];
     readonly annotations: readonly string[];
@@ -717,7 +719,8 @@ export interface SemanticIndex {
  *
  * @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.
+ *   to. `-1` for a section, folder or package, and for a page or entry that would be alone in its community, which
+ *   belong to none.
  */
 export interface CommunityIndex {
     readonly labels: readonly string[];

package/dist/model/registry.d.ts

@@ -508,6 +508,11 @@ export declare const RELATION_FAMILY_REGISTRY: {
         readonly description: 'What a source file includes, and what a function calls.';
         readonly colorToken: '--edge-code';
     };
+    readonly callback: {
+        readonly label: 'callback';
+        readonly description: 'A function another function hands on as a value.';
+        readonly colorToken: '--edge-callback';
+    };
 };
 /** Every relation kind other than `parent`, in the order the site lists them. */
 export declare const RELATION_KIND_REGISTRY: {
@@ -643,6 +648,15 @@ export declare const RELATION_KIND_REGISTRY: {
         readonly family: 'code';
         readonly dashed: true;
     };
+    readonly passes: {
+        readonly label: 'passes';
+        readonly description: 'A function or method hands that function or method on as a value, such as a callback, without calling it.';
+        readonly forward: 'passes';
+        readonly backward: 'is passed by';
+        readonly from: 'function or method';
+        readonly to: 'function or method';
+        readonly family: 'callback';
+    };
 };
 /** Slug of a top-level section, such as `code`. */
 export type Section = keyof typeof SECTION_REGISTRY;

package/dist/query/graph.d.ts

@@ -60,7 +60,8 @@ export declare class Graph {
      * @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.
+     * @returns The id of its community, or `null` for a section, folder or package, for a node alone, and in a bundle
+     *   without communities.
      */
     communityOf(ref: NodeRef): number | null;
     /**

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

@@ -9,7 +9,10 @@ import type { Graph } from './graph';
  * @property group - Name of the section the node is in. Results are grouped by it.
  * @property title - Name shown in the results.
  * @property detail - Text shown beside the title, such as a file path.
- * @property haystack - Lowercase text that names the node: its title, the words of its name, the words it replaces.
+ * @property haystack - Lowercase text that names the node: its title, the words of its name, the words it replaces,
+ *   and the names of its members.
+ * @property own - The part of `haystack` that names the node itself, without its members.
+ * @property members - Each parameter, field, operation or definition whose name `haystack` holds, with its own words.
  * @property place - Lowercase words of `detail`, each with a space in front of it.
  * @property text - Lowercase words that describe the node: its description, its definition, the page.
  *   Every word has a space in front of it, so a search can tell the start of a word from its middle.
@@ -24,18 +27,33 @@ export interface SearchEntry {
     readonly title: string;
     readonly detail: string;
     readonly haystack: string;
+    readonly own: string;
+    readonly members: readonly SearchMember[];
     readonly place: string;
     readonly text: string;
 }
+/**
+ * @brief A member whose name is in the entry of its owner.
+ *
+ * @property node - The member node, such as a field.
+ * @property haystack - Lowercase text that names the member, as the member entry holds it.
+ */
+export interface SearchMember {
+    readonly node: NodeRef;
+    readonly haystack: string;
+}
 /**
  * One result of a search by words.
  *
  * @property entry - The entry that matched.
  * @property found - `name` when every word of the query is in what names the node. `text` when at least one word is only in what describes it.
+ * @property member - For a match by name that needs the name of a member, the first member whose words, with the
+ *   node's own, hold every word of the query. `null` when the node's own name holds them, and for a match by text.
  */
 export interface SearchMatch {
     readonly entry: SearchEntry;
     readonly found: 'name' | 'text';
+    readonly member: NodeRef | null;
 }
 /**
  * @brief Builds the index for search by words: one entry per file, symbol, glossary term, decision, table,

package/dist/retrieval/describe.d.ts

@@ -1,6 +1,6 @@
 import { type EdgeKind, type NodeRef } from '../model';
 import { type Graph } from '../query';
-import type { NodeReport, References } from './report';
+import type { NodeReport, Reference, References } from './report';
 /**
  * @brief Which edges of a node to report.
  *
@@ -13,6 +13,38 @@ export interface ReferenceOptions {
 }
 /** The options that keep every edge in both directions. */
 export declare const ALL_REFERENCES: ReferenceOptions;
+/**
+ * @brief One edge of a node, seen from the node: the relation, the page or entry at the other end, and the
+ * parameter or field it runs through.
+ *
+ * @property relation - Kind of the edge.
+ * @property node - The page or entry at the other end. A parameter or field there counts as its symbol.
+ * @property via - For a `type` edge, the name of the parameter or field of the node it starts at, else `null`.
+ */
+export interface Step {
+    readonly relation: EdgeKind;
+    readonly node: NodeRef;
+    readonly via: string | null;
+}
+/**
+ * @brief Lists the edges of a node in one direction, each once. The edges of its parameters and fields count as its
+ * own, as on its page.
+ *
+ * @param graph - Graph the node belongs to.
+ * @param node - A page or an entry.
+ * @param direction - `out` for the edges that start at the node, `in` for those that end at it.
+ * @param kinds - Edge kinds to keep. Empty keeps every kind.
+ * @returns The steps in edge order.
+ */
+export declare function stepsOf(graph: Graph, node: NodeRef, direction: 'in' | 'out', kinds: readonly EdgeKind[]): Step[];
+/**
+ * @brief Turns a step into the reference a report shows.
+ *
+ * @param graph - Graph the step belongs to.
+ * @param step - The step.
+ * @returns The relation, the summary of the other node, and the parameter or field it runs through.
+ */
+export declare function referenceOf(graph: Graph, step: Step): Reference;
 /**
  * @brief Lists the edges of a node in both directions. The edges of its parameters
  * and fields count as its own, as on its page.

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

@@ -30,9 +30,13 @@ export interface GraphExportOptions {
  * @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 community - Id of the community of the node, or `null` for a section, folder or package and for a node
+ *   that would be alone in one.
  * @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.
+ * @property size - For a community: the number of pages and entries in it. Absent on every other node.
+ * @property members - For a community: its best-linked pages and entries, the best first, at most
+ *   `COMMUNITY_MEMBERS`. Absent on every other node.
  */
 export interface ExportNode {
     readonly id: string;
@@ -42,7 +46,23 @@ export interface ExportNode {
     readonly package: string | null;
     readonly community: number | null;
     readonly parent: string | null;
+    readonly size?: number;
+    readonly members?: readonly CommunityMember[];
 }
+/**
+ * @brief A page or entry of a community, as the export of the community lists it.
+ *
+ * @property id - Id of the node, as `show` and `refs` take it.
+ * @property name - Path of a file, or the qualified name of an entry, such as `Retriever.search`.
+ * @property links - Number of edges of the node, both ways, that the `all` level of the graph page draws.
+ */
+export interface CommunityMember {
+    readonly id: string;
+    readonly name: string;
+    readonly links: number;
+}
+/** Most members the export of one community lists. */
+export declare const COMMUNITY_MEMBERS = 5;
 /**
  * @brief Edges of one kind between two nodes of an export.
  *

package/dist/retrieval/index.d.ts

@@ -1,8 +1,9 @@
 export { ALL_REFERENCES, describeNode, type ReferenceOptions, referencesOf } from './describe';
+export { DEFAULT_WALK_LIMIT, shortestPath, type Walk, type WalkOptions, type WalkReference, walkReferences } from './walk';
 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 { COMMUNITY_MEMBERS, type CommunityMember, 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';
-export { Retriever, SEARCH_MODES, type SearchHit, type SearchMode, type SearchOptions } from './retriever';
+export type { ContentReport, DatabaseObjectReport, DeclarationReport, MemberMatch, ForeignKeyReport, NodeReport, NodeSummary, OperationReport, QueryReport, Reference, References, TableReport, TagReport, TaskReport, } from './report';
+export { type Candidate, closestNames, type Resolution, resolveNode } from './resolve';
+export { type HitPlace, Retriever, SEARCH_MODES, type SearchHit, type SearchMode, type SearchOptions } from './retriever';
 export { nodeId, normalizeId, summarize } from './summary';

package/dist/retrieval/report.d.ts

@@ -9,6 +9,8 @@ import type { ApiServer, DocTagKind, EdgeKind, NodeKind, NodeType, PackageRole,
  * @property note - A short fact that belongs beside the title: the status of a decision, a plan, a phase or a task, the language of a source file, the version of an API, the verb of a query. `''` for other nodes.
  * @property path - Path on disk of the file the node is or is in. For a catalog, the path of its directory. `null` for a section or a folder.
  * @property line - Line of a symbol, a table or a query in its file. `null` for every other node.
+ * @property endLine - Last line of a symbol in its file. `null` for every other node, and for a symbol of a site
+ *   written before end lines existed.
  * @property summary - First paragraph of its description, as plain text. A table or a query without a description gets what its SQL states instead: the number of columns and the tables it is connected to, or the tables it reads and writes. `''` for any other node without a description.
  */
 export interface NodeSummary {
@@ -19,8 +21,20 @@ export interface NodeSummary {
     readonly note: string;
     readonly path: string | null;
     readonly line: number | null;
+    readonly endLine: number | null;
     readonly summary: string;
 }
+/**
+ * @brief The parameter, field, operation or definition of a node that a name or a search matched, when the node's
+ * own name did not.
+ *
+ * @property kind - Kind of the member, such as `field`.
+ * @property name - Name of the member, such as `hashFile`.
+ */
+export interface MemberMatch {
+    readonly kind: NodeKind;
+    readonly name: string;
+}
 /**
  * @brief A parameter or a field of a symbol, a parameter of an operation, a property of a definition, a column of a table, or a placeholder or a result column of a query.
  *

package/dist/retrieval/resolve.d.ts

@@ -1,5 +1,16 @@
 import { type NodeRef } from '../model';
 import type { Graph } from '../query';
+/**
+ * @brief One node a name fits, with the parameter, field, operation or definition of it that the name matched.
+ *
+ * @property node - The node.
+ * @property member - The member whose name matched, such as the field `hashFile` of an interface. `null` when the
+ *   name of the node itself matched.
+ */
+export interface Candidate {
+    readonly node: NodeRef;
+    readonly member: NodeRef | null;
+}
 /**
  * @brief What a reference to a node turned out to name.
  *
@@ -11,7 +22,7 @@ export type Resolution = {
     readonly node: NodeRef;
 } | {
     readonly kind: 'ambiguous';
-    readonly candidates: readonly NodeRef[];
+    readonly candidates: readonly Candidate[];
 } | {
     readonly kind: 'missing';
 };
@@ -29,3 +40,16 @@ export type Resolution = {
  * @returns The node, the candidates when several fit the deciding rule, or `missing`. A match by name on a parameter, field, operation or definition returns the node it belongs to, see `resultOf`; its id returns the node itself.
  */
 export declare function resolveNode(graph: Graph, text: string, accepts: (node: NodeRef) => boolean): Resolution;
+/**
+ * @brief Finds the names closest to a name that fits no node, such as `installSkillPackages` for
+ * `instalSkillPackages`, capitals ignored.
+ *
+ * A name counts when at most one edit in four characters turns it into the text, and at least one edit always
+ * counts.
+ *
+ * @param graph - Graph to search.
+ * @param text - The name that fit no node.
+ * @param accepts - Narrows the nodes that count, such as to one kind.
+ * @returns Up to three names, the closest first. Empty when none is close.
+ */
+export declare function closestNames(graph: Graph, text: string, accepts: (node: NodeRef) => boolean): string[];

package/dist/retrieval/retriever.d.ts

@@ -1,10 +1,10 @@
-import type { NodeRef } from '../model';
+import { type EdgeKind, type NodeRef, type Section } 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 { MemberMatch, NodeReport, NodeSummary, Reference } from './report';
 import { type Resolution } from './resolve';
+import { type Walk, type WalkOptions } from './walk';
 /** The search modes a caller can pick from, the default first. */
 export declare const SEARCH_MODES: readonly ['both', 'name', 'meaning'];
 /** How a search matches: `name` by the words of a name or a description, `meaning` by the embedding model, `both` by words first and then by meaning. */
@@ -27,11 +27,30 @@ 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.
+ * @property member - The parameter, field, operation or definition of the node that matched, such as the field
+ *   `hashFile` of an interface. `null` when the node matched by its own name, text or meaning.
+ * @property section - Section the node is in.
+ * @property duplicates - Other nodes the same search found that this hit stands for, because they match the same way
+ *   with the same kind, type, title, summary and score, such as nine `hooks.json` files that say nothing. Each with
+ *   its id and path. Empty for a hit that stands for itself only.
  */
 export interface SearchHit extends NodeSummary {
     readonly match: 'name' | 'text' | 'meaning';
     readonly score: number | null;
     readonly weak?: true;
+    readonly member: MemberMatch | null;
+    readonly section: Section;
+    readonly duplicates: readonly HitPlace[];
+}
+/**
+ * @brief Where a node a search hit stands for is.
+ *
+ * @property id - Id of the node.
+ * @property path - Path on disk of the file the node is or is in, or `null`.
+ */
+export interface HitPlace {
+    readonly id: string;
+    readonly path: string | null;
 }
 /**
  * @brief Answers queries on one bundle: search, list, look up, describe, export.
@@ -58,6 +77,12 @@ export declare class Retriever {
      * @returns The name, or `null` when the bundle was built without embeddings.
      */
     get model(): string | null;
+    /**
+     * @brief Lists the sections the bundle has, in display order. A bundle can lack one, such as `database`.
+     *
+     * @returns The slugs of its sections.
+     */
+    get sections(): readonly Section[];
     /**
      * @brief Finds pages and entries for a query. Matches by words come first, in the
      * order the site lists them. Matches by meaning follow, best first.
@@ -76,6 +101,17 @@ export declare class Retriever {
      * @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 Builds the hit of one node, standing for itself only.
+     *
+     * @param node - The node the hit returns.
+     * @param member - The member of it that matched, or `null` when the node matched itself.
+     * @param match - How it matched.
+     * @param score - Its score by meaning, or `null` for a match by words.
+     * @returns The hit, without duplicates.
+     * @throws {Error} When the node is in no section, which a bundle never allows.
+     */
+    private hitOf;
     /**
      * @brief Lists pages and entries in display order.
      *
@@ -92,6 +128,21 @@ export declare class Retriever {
      * @returns The node, the candidates when several fit, or `missing`.
      */
     resolve(text: string, filter: NodeFilter): Resolution;
+    /**
+     * @brief Finds the names closest to a name that fits no node, for a caller who mistyped it.
+     *
+     * @param text - The name that fit no node.
+     * @param filter - Narrows the nodes that count, as for `resolve`.
+     * @returns Up to three names, the closest first. Empty when none is close.
+     */
+    suggest(text: string, filter: NodeFilter): string[];
+    /**
+     * @brief Names a parameter, field, operation or definition that a name or a search matched.
+     *
+     * @param member - The member node.
+     * @returns Its kind and name.
+     */
+    memberOf(member: NodeRef): MemberMatch;
     /**
      * @brief Describes a node in one row.
      *
@@ -107,13 +158,22 @@ export declare class Retriever {
      */
     describe(node: NodeRef): NodeReport;
     /**
-     * @brief Lists the edges of a node.
+     * @brief Follows the edges of a node for some hops in each direction, the closest first.
      *
      * @param node - A page or an entry.
-     * @param options - Which edges to keep, by direction and kind.
-     * @returns What the node links to and what links to it.
+     * @param options - Direction, edge kinds, depth and the most references to list.
+     * @returns What the node links to and what links to it, each with its next hop, and how many the limit left out.
+     */
+    walk(node: NodeRef, options: WalkOptions): Walk;
+    /**
+     * @brief Finds the shortest chain of edges from one node to another, following edges the way they point.
+     *
+     * @param from - The node the chain starts at.
+     * @param to - The node the chain ends at.
+     * @param kinds - Edge kinds to follow. Empty follows every kind.
+     * @returns Each reference of the chain in order, or `null` when no chain leads from `from` to `to`.
      */
-    references(node: NodeRef, options?: ReferenceOptions): References;
+    path(from: NodeRef, to: NodeRef, kinds: readonly EdgeKind[]): Reference[] | null;
     /**
      * @brief Exports one level of the bundle as nodes and edges.
      *

package/dist/retrieval/walk.d.ts

@@ -0,0 +1,66 @@
+import type { EdgeKind, NodeRef } from '../model';
+import type { Graph } from '../query';
+import type { Reference } from './report';
+/** Most references a walk lists without a limit. */
+export declare const DEFAULT_WALK_LIMIT = 50;
+/**
+ * @brief How far a walk of the references of a node goes.
+ *
+ * @property direction - `in` for what links to the node, `out` for what it links to, `both` for either.
+ * @property kinds - Edge kinds to follow. Empty follows every kind.
+ * @property depth - Hops to follow from the node. 1 lists its own references.
+ * @property limit - Most references to list, both directions and every hop together.
+ */
+export interface WalkOptions {
+    readonly direction: 'in' | 'out' | 'both';
+    readonly kinds: readonly EdgeKind[];
+    readonly depth: number;
+    readonly limit: number;
+}
+/**
+ * @brief A reference with the references of its node one hop further, in the same direction.
+ *
+ * @property next - What the node of this reference links to, or what links to it, on the next hop. Empty on the
+ *   last hop, for a node listed under another reference already, and for a node the limit cut off.
+ */
+export interface WalkReference extends Reference {
+    readonly next: readonly WalkReference[];
+}
+/**
+ * @brief The references of a node, followed for some hops in each direction.
+ *
+ * @property linksTo - What the node links to, each with what that links to on the next hop.
+ * @property linkedFrom - What links to the node, each with what links to that on the next hop.
+ * @property omitted - References the walk reached within its depth but did not list, because of its limit.
+ */
+export interface Walk {
+    readonly linksTo: readonly WalkReference[];
+    readonly linkedFrom: readonly WalkReference[];
+    readonly omitted: number;
+}
+/**
+ * @brief Follows the references of a node for some hops, breadth first, so the closest references are listed
+ * before the limit cuts the rest.
+ *
+ * Each hop takes its steps from both directions in turn, so neither direction uses up the limit alone. A node is
+ * listed once per direction: under the first reference that reaches it, with every relation that reference's node
+ * has to it. The start node is never listed again. Past the limit the walk goes on to its depth without listing,
+ * so it counts every reference it leaves out.
+ *
+ * @param graph - Graph the node belongs to.
+ * @param start - The node the walk starts at.
+ * @param options - Direction, edge kinds, depth and limit.
+ * @returns Both directions of the walk, and how many references the limit left out.
+ */
+export declare function walkReferences(graph: Graph, start: NodeRef, options: WalkOptions): Walk;
+/**
+ * @brief Finds the shortest chain of edges from one node to another, following edges the way they point.
+ *
+ * @param graph - Graph both nodes belong to.
+ * @param from - The node the chain starts at.
+ * @param to - The node the chain ends at.
+ * @param kinds - Edge kinds to follow. Empty follows every kind.
+ * @returns The references from `from` to `to`, in order, each to the next node of the chain. Empty when `from` is
+ *   `to`. `null` when no chain leads there.
+ */
+export declare function shortestPath(graph: Graph, from: NodeRef, to: NodeRef, kinds: readonly EdgeKind[]): Reference[] | null;

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

@@ -26,17 +26,32 @@ export interface RawCall {
     readonly qualifier: readonly string[];
 }
 /**
- * @brief Reads every call in a function body, each once, in the order they first appear.
+ * @brief The calls in a function body, and the functions it passes on as values.
  *
- * 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
+ * @property calls - Every call, each once, in the order they first appear.
+ * @property passes - Every name the body hands on as a value without calling it, such as the callback in
+ *   `run(onDone)` or the entry of `{ add: addCommand }`, each once. A name the body binds itself is left out.
+ */
+export interface BodyReferences {
+    readonly calls: readonly RawCall[];
+    readonly passes: readonly RawCall[];
+}
+/**
+ * @brief Reads the calls of a function body, and the functions it passes on as values.
+ *
+ * Calls and values inside a nested definition belong to that definition and are left out. Those 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.
  *
+ * A value counts when it is an argument of a call, an element of an array or a list, or the value of a key of an
+ * object or a dict, and names a function: `onDone`, `this.flush` or `Timer.once`. A name the body binds, as a
+ * local, a loop variable, a catch variable or a lambda parameter, never counts, since it is no function of the scan.
+ *
  * @param body - Body node of the function.
  * @param definitions - Ids of the definition nodes of the file.
- * @returns The calls the body makes.
+ * @returns The calls and the passed values of the body.
  */
-export declare function readCalls(body: Node, definitions: ReadonlySet<number>): RawCall[];
+export declare function readReferences(body: Node, definitions: ReadonlySet<number>): BodyReferences;
 /**
  * @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.
@@ -55,7 +70,8 @@ export interface CallContext {
     readonly implicitReceiver: boolean;
 }
 /**
- * @brief Turns the calls of a function into `calls` edges to the functions of the scan they reach.
+ * @brief Turns the calls of a function into `calls` edges, and the functions it passes on into `passes` 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
@@ -63,13 +79,14 @@ export interface CallContext {
  * 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
+ * Holds the indexes it resolves against, the graph it adds edges to, the fields of each type, and the getters and
+ * setters, which a value never hands on. 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() });
+ * calls.link(functionRef, rawSymbol.calls, { scope, owners: ['geo'], variables: new Map() }, 'calls');
  */
 export declare class CallLinker {
     private readonly types;
@@ -77,6 +94,7 @@ export declare class CallLinker {
     private readonly sources;
     private readonly graph;
     private readonly fields;
+    private readonly accessors;
     /**
      * Takes the indexes the calls resolve against and the graph the edges are added to.
      *
@@ -102,13 +120,22 @@ export declare class CallLinker {
      */
     fieldsAround(context: Pick<CallContext, 'scope' | 'owners'>): ReadonlyMap<string, string>;
     /**
-     * @brief Records a `calls` edge from `from` to each function its calls reach.
+     * @brief Records an edge from `from` to each function its calls or its passed values reach.
      *
-     * @param from - Node of the calling function.
-     * @param calls - The calls in its body.
+     * A passed value resolves the way a call of the same name would.
+     *
+     * @param from - Node of the function.
+     * @param calls - The calls in its body, or the values it passes on.
      * @param context - Where the function is.
+     * @param kind - `calls` for calls, `passes` for values passed on.
+     */
+    link(from: NodeRef, calls: readonly RawCall[], context: CallContext, kind: 'calls' | 'passes'): void;
+    /**
+     * @brief Records that a method is a getter or a setter, which a value names without handing it on.
+     *
+     * @param method - Node of the getter or setter.
      */
-    link(from: NodeRef, calls: readonly RawCall[], context: CallContext): void;
+    registerAccessor(method: NodeRef): void;
     /**
      * @brief The function one call reaches.
      *

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

@@ -0,0 +1,70 @@
+import type { Node } from 'web-tree-sitter';
+import type { SourceFileIndex } from './imports';
+/**
+ * @brief One name an `export { … } from` statement hands on.
+ *
+ * @property name - Name the other file exports it under, such as `hashFile`.
+ * @property as - Name this file exports it under: the same name, or the alias of `name as alias`.
+ */
+export interface ReexportedName {
+    readonly name: string;
+    readonly as: string;
+}
+/**
+ * @brief One `export … from` statement.
+ *
+ * @property specifier - The file it names, as written, such as `./hash`.
+ * @property names - The names it hands on, or `null` for `export * from`, which hands on every name.
+ */
+export interface Reexport {
+    readonly specifier: string;
+    readonly names: readonly ReexportedName[] | null;
+}
+/**
+ * @brief What a file exports by name. A default export is left out.
+ *
+ * @property declared - What the file declares and exports itself, each with the name it is exported under:
+ *   `export function load()`, `export { load }` or `export { load as start }`.
+ * @property reexports - The `export … from` statements of the file in file order, and each `export { name }` of a name
+ *   the file imports, which hands that name on from the file it came from.
+ */
+export interface FileExports {
+    readonly declared: readonly ReexportedName[];
+    readonly reexports: readonly Reexport[];
+}
+/**
+ * @brief How code outside a package imports a symbol: by the package name, or one of its subpaths, and the name the
+ * entry file there exports.
+ *
+ * @property specifier - What the import names: the package, such as `@g3nomaly/skills`, or a subpath of it, such as
+ *   `@g3nomaly/core/hash`.
+ * @property name - Name the entry file exports the symbol under, such as `hashFile`.
+ */
+export interface PackageImport {
+    readonly specifier: string;
+    readonly name: string;
+}
+/** The exports of a file that exports nothing by name, or whose language has no exports. */
+export declare const NO_EXPORTS: FileExports;
+/**
+ * @brief Reads the exports of a JavaScript or TypeScript file.
+ *
+ * @param root - Root node of the parsed file.
+ * @returns The names it declares and exports, and the names it hands on from other files. `export default` and
+ *   `export * as name from` are left out, since neither exports a name of the other file.
+ */
+export declare function readEcmascriptExports(root: Node): FileExports;
+/**
+ * @brief Finds how code outside a package imports a symbol: through the first entry point of the package the file is
+ * in whose entry file exports the symbol, itself or through `export … from` statements.
+ *
+ * The entry points are the package name and the subpaths its manifest lists. The entry file of one is the file an
+ * import of it resolves to, such as `packages/core/src/hash/index.ts` for `@g3nomaly/core/hash`.
+ *
+ * @param sources - The source files and packages of the scan.
+ * @param path - Display path of the file that declares the symbol.
+ * @param name - Name the file declares the symbol under.
+ * @returns The specifier and the name the entry exports, or `null` when the file is in no package of the scan or
+ *   no entry file exports the symbol.
+ */
+export declare function packageImportOf(sources: SourceFileIndex, path: string, name: string): PackageImport | null;