@g3nomaly/analyze 0.1.5 → 0.1.7

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[];
@@ -659,8 +661,12 @@ export type DescribedNode = SymbolNode | OperationNode | DefinitionNode | TableN
  * @returns True for a symbol, an operation, a definition, a table and a query.
  */
 export declare function isDescribedNode(node: GraphNode): node is DescribedNode;
-/** A relation other than `parent` between two nodes, such as a parameter that has a class as its type. */
-export type Edge = readonly [from: NodeRef, kind: EdgeKind, to: NodeRef];
+/**
+ * A relation other than `parent` between two nodes, such as a parameter that has a class as its type. `lines` are
+ * the lines of the file of `from` where the link is made, in order, such as those of a call or an import. An edge
+ * with no line of its own leaves them out.
+ */
+export type Edge = readonly [from: NodeRef, kind: EdgeKind, to: NodeRef, lines?: readonly number[]];
 /**
  * What the bundle says about its own making.
  *
@@ -717,7 +723,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,65 @@ 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`.
+ * @property source - Node the edge starts at, whose file holds `lines`.
+ * @property lines - Lines where the link is made, of every edge the step stands for, in order. Empty when the
+ *   edges record none.
+ */
+export interface Step {
+    readonly relation: EdgeKind;
+    readonly node: NodeRef;
+    readonly via: string | null;
+    readonly source: NodeRef;
+    readonly lines: readonly number[];
+}
+/**
+ * @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 Finds the file a node is in: the node itself when it is a file or a source file, else its closest such
+ * ancestor.
+ *
+ * @param graph - Graph the node belongs to.
+ * @param node - Any node.
+ * @returns The file, or the node itself when no file holds it, as for a folder or a package.
+ */
+export declare function fileOf(graph: Graph, node: NodeRef): NodeRef;
+/**
+ * @brief Lists the links of a file to other files in one direction, as the file level of the graph page draws
+ * them: every edge of the file and of the entries in it counts for the file, and every edge to another file or an
+ * entry in it counts for that file. Edges inside the file are left out. Nothing is stored for these links.
+ *
+ * @param graph - Graph the file belongs to.
+ * @param file - A file, as `fileOf` gives it.
+ * @param direction - `out` for what the file links to, `in` for what links to it.
+ * @param kinds - Edge kinds to keep. Empty keeps every kind.
+ * @returns One step per other file and edge kind, with the lines of every edge it stands for.
+ */
+export declare function fileStepsOf(graph: Graph, file: 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, the parameter or field it runs through, and where the link
+ *   is made.
+ */
+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 { ALL_REFERENCES, describeNode, fileOf, type ReferenceOptions, referencesOf } from './describe';
+export { DEFAULT_WALK_LIMIT, shortestPath, WALK_LEVELS, type Walk, type WalkLevel, 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.
  *
@@ -175,11 +189,18 @@ export interface TagReport {
  * @property relation - Kind of the edge.
  * @property node - The node at the other end. For a parameter or a field, the symbol that declares it.
  * @property via - Name of the parameter or field the edge starts at, when it does not start at a page or an entry.
+ * @property location - Where the link is made: the file of the node the edge starts at and the lines in it, e.g.
+ *   `{ path: "packages/core/src/cli/commands/add.ts", lines: [86] }` for a call. `null` when the edge records no
+ *   lines.
  */
 export interface Reference {
     readonly relation: EdgeKind;
     readonly node: NodeSummary;
     readonly via: string | null;
+    readonly location: {
+        readonly path: string;
+        readonly lines: readonly number[];
+    } | null;
 }
 /**
  * @brief Both directions of the edges of a node.

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,30 @@ 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 file a node is in.
+     *
+     * @param node - Any node.
+     * @returns The node itself when it is a file, else its closest file ancestor, else the node.
+     */
+    fileOf(node: NodeRef): NodeRef;
+    /**
+     * @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 but `mentions`, unless `includeMentions` is set.
+     * @param includeMentions - Whether an empty `kinds` follows `mentions` too.
+     * @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[], includeMentions?: boolean): Reference[] | null;
     /**
      * @brief Exports one level of the bundle as nodes and edges.
      *

package/dist/retrieval/summary.d.ts

@@ -17,6 +17,14 @@ export declare function nodeId(graph: Graph, node: NodeRef): string;
  * @returns The id without the file, `#/` or slashes around it, with percent escapes decoded.
  */
 export declare function normalizeId(text: string): string;
+/**
+ * @brief Finds the path on disk that belongs to a node.
+ *
+ * @param graph - Graph the node belongs to.
+ * @param node - The node to look up.
+ * @returns The path of the node itself, else of the file it is in. `null` for a section or a folder.
+ */
+export declare function pathOf(graph: Graph, node: NodeRef): string | null;
 /**
  * @brief Describes a node in one row: what a search hit, a list row and a reference show.
  *

package/dist/retrieval/walk.d.ts

@@ -0,0 +1,77 @@
+import { type EdgeKind, type 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;
+/** Levels a walk can follow links at: between pages and entries, or between the files that hold them. */
+export declare const WALK_LEVELS: readonly ['entries', 'files'];
+/** A level a walk follows links at. */
+export type WalkLevel = (typeof WALK_LEVELS)[number];
+/**
+ * @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.
+ * @property level - `entries` follows the stored links. `files` follows them between the files that hold their
+ *   ends, as the file level of the graph page draws them, and starts at the file of the node.
+ */
+export interface WalkOptions {
+    readonly direction: 'in' | 'out' | 'both';
+    readonly kinds: readonly EdgeKind[];
+    readonly depth: number;
+    readonly limit: number;
+    readonly level: WalkLevel;
+}
+/**
+ * @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.
+ *
+ * Of the chains that are equally short, the one with the fewest `mentions` steps wins, so a link a description makes
+ * only stands in for code where code offers no chain as short.
+ *
+ * @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 but `mentions`, unless `includeMentions` is set.
+ * @param includeMentions - Whether an empty `kinds` follows `mentions` too.
+ * @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[], includeMentions?: boolean): Reference[] | null;