@g3nomaly/analyze 0.0.0-stage → 0.1.0

package/dist/model/index.d.ts

@@ -0,0 +1,560 @@
+import { type EdgeKind, type KindsIn, type NodeKind, type Section } from './registry';
+/** Index of a node in {@link DocsBundle.nodes}. */
+export type NodeRef = number;
+export { ALL_NODE_KINDS, EDGE_KINDS, type EdgeKind, kindsIn, kindsWith, NODE_KINDS, type NodeGroup, type NodeKind, type NodeKindSpec, RELATION_FAMILIES, RELATION_FAMILY_NAMES, RELATION_KINDS, type RelationFamily, type RelationFamilySpec, type RelationKindSpec, SECTION_SPECS, SECTIONS, type Section, type SectionSpec, } from './registry';
+/** Kinds of a declaration in code. */
+export declare const SYMBOL_KINDS: readonly KindsIn<"symbol">[];
+/** A kind of a declaration in code. */
+export type SymbolKind = KindsIn<'symbol'>;
+/** Kinds a type name can refer to. */
+export declare const TYPE_KINDS: ReadonlySet<SymbolKind>;
+/** Kinds that own member symbols. */
+export declare const CONTAINER_KINDS: ReadonlySet<SymbolKind>;
+/**
+ * Kinds of a file that has a page. See `NODE_KIND_REGISTRY` for what each one is.
+ * A `glossary`, `decisions`, `schema`, `api`, `database` or `catalog` node has its entries as children.
+ */
+export declare const FILE_KINDS: readonly KindsIn<"file">[];
+/** A kind of a file that has a page. */
+export type FileKind = KindsIn<'file'>;
+/**
+ * Kinds shown as an **entry**: a block on the page of the file they are in,
+ * with an anchor of its own. Symbols are entries of a source file, terms of a
+ * glossary, decisions of a decision log, operations of an OpenAPI document,
+ * definitions of an OpenAPI document or a JSON Schema, tables of a database,
+ * queries of a query catalog.
+ */
+export declare const ENTRY_KINDS: readonly KindsIn<"entry" | "symbol">[];
+/** A kind shown as an entry. */
+export type EntryKind = KindsIn<'symbol' | 'entry'>;
+/** Kinds a node with an id can have: every kind but parameter and field. */
+export declare const LISTED_KINDS: readonly KindsIn<"entry" | "file" | "folder" | "section" | "source" | "symbol">[];
+/** Tells a symbol kind from the others. */
+export declare function isSymbolKind(kind: NodeKind): kind is SymbolKind;
+/** Tells the kind of a file with a page from the others. */
+export declare function isFileKind(kind: NodeKind): kind is FileKind;
+/** Tells an entry kind, a symbol included, from the others. */
+export declare function isEntryKind(kind: NodeKind): kind is EntryKind;
+/** What every node states, whatever its kind. */
+interface NodeBase<K extends NodeKind> {
+    readonly kind: K;
+    /** Shown in the tree: a file name, a symbol name, a parameter name. */
+    readonly name: string;
+    /** The node this one belongs to. `null` for a section. */
+    readonly parent: NodeRef | null;
+    /** Segment of the node's route. Defaults to `name`. */
+    readonly slug?: string;
+}
+/** One of the top-level groups. */
+export interface SectionNode extends NodeBase<'section'> {
+    readonly slug: Section;
+}
+/** A directory of the scanned repository. */
+export type FolderNode = NodeBase<'folder'>;
+/** A heading of a markdown page, for its table of contents. `id` is the anchor of the heading. */
+export interface Heading {
+    readonly id: string;
+    readonly text: string;
+    readonly depth: number;
+}
+/** What a file looks like on its page. */
+export type FileContent = {
+    readonly format: 'markdown';
+    readonly html: string;
+    readonly headings: readonly Heading[];
+}
+/** A `<pre>` block, highlighted when the file is small enough. */
+ | {
+    readonly format: 'text';
+    readonly html: string;
+}
+/** `src` is a `data:` URI. */
+ | {
+    readonly format: 'image';
+    readonly src: string;
+} | {
+    readonly format: 'omitted';
+    readonly reason: 'binary' | 'large';
+    readonly bytes: number;
+};
+/** What every file with a page states. */
+interface FileFacts {
+    /** Path as it is on disk, relative to the scanned root. For a `catalog`, the path of its directory. */
+    readonly path: string;
+    /** Frontmatter `title` or `name`, else the first heading, else the file name. */
+    readonly title: string;
+    /** Frontmatter `description`, or `''`. */
+    readonly description: string;
+    readonly content: FileContent;
+}
+/**
+ * A file shown as it is. A `skill` node is the skill's `SKILL.md`, and the skill's other files are its descendants.
+ * For a `glossary` or `decisions` node, `content` is the text around its entries, and the entries are its children.
+ * A `schema` node that is a JSON Schema has its definitions as children.
+ * A `catalog` node has no content of its own: its queries are its children.
+ */
+export interface FileNode extends NodeBase<Exclude<FileKind, 'api' | 'database' | 'plan' | 'phase'>>, FileFacts {
+}
+/** A base URL an API is served from. */
+export interface ApiServer {
+    readonly url: string;
+    /** Plain text, or `''`. */
+    readonly description: string;
+}
+/** A group of operations of an OpenAPI document. */
+export interface ApiTag {
+    readonly name: string;
+    readonly descriptionHtml: string;
+}
+/**
+ * An OpenAPI document. Its operations and its schema definitions are its
+ * children. `title` is the title of the API, `description` its summary, and
+ * `content` its description.
+ */
+export interface ApiNode extends NodeBase<'api'>, FileFacts {
+    /** Version of the API, from `info.version`. */
+    readonly version: string;
+    /** Version of the OpenAPI format the document is written in, such as `3.1.0`. */
+    readonly specVersion: string;
+    readonly servers: readonly ApiServer[];
+    /** The tags the document declares, in its order. An operation can name a tag that is not listed here. */
+    readonly tags: readonly ApiTag[];
+}
+/** A view or a trigger of a database schema. */
+export interface DatabaseObject {
+    readonly kind: 'view' | 'trigger';
+    readonly name: string;
+    /** The table a trigger fires on. `''` for a view. */
+    readonly table: string;
+    readonly line: number;
+    readonly descriptionHtml: string;
+    /** The highlighted statement that creates it. */
+    readonly sqlHtml: string;
+}
+/**
+ * A `.sql` file that creates tables. Its tables are its children. `content`
+ * is the comment that opens the file.
+ */
+export interface DatabaseNode extends NodeBase<'database'>, FileFacts {
+    /** Views and triggers, in file order. */
+    readonly objects: readonly DatabaseObject[];
+}
+/** A source file. Its symbols are its descendants. */
+export interface SourceNode extends NodeBase<'source'> {
+    readonly path: string;
+    readonly language: string;
+    /** What the language calls its annotations: `Decorators`, `Attributes` or `Annotations`. */
+    readonly annotationLabel: string;
+    /** The file's text. Set for a skill's code, `null` in the code section. */
+    readonly content: FileContent | null;
+}
+/** `[start, end, target]`: the characters `start` to `end` of a text name the node `target`. */
+export type TextLink = readonly [start: number, end: number, target: NodeRef];
+/** Source text in which some spans name other nodes, such as `Promise<Booking>` with `Booking` linked. */
+export interface LinkedText {
+    readonly text: string;
+    /** In text order, not overlapping. */
+    readonly links: readonly TextLink[];
+}
+/** Doc comment tags that are not folded into parameters, return value or fields. */
+export type DocTagKind = 'throws' | 'deprecated' | 'see' | 'since' | 'other';
+/** A tag of a doc comment, such as `@throws` or `@deprecated`. */
+export interface DocTag {
+    readonly kind: DocTagKind;
+    /** Original tag label, for example `typeParam`. Set when `kind` is `other`. */
+    readonly label?: string;
+    /** What the tag is about, such as the exception type of a `throws` tag. */
+    readonly subject: LinkedText | null;
+    readonly html: string;
+}
+/** What a function returns: its type and the description of its doc comment. */
+export interface ReturnInfo {
+    readonly type: LinkedText | null;
+    readonly descriptionHtml: string;
+}
+/** A highlighted usage example of a symbol. */
+export interface SymbolExample {
+    readonly html: string;
+    /** `documented` comes from the doc comment, `generated` from the signature. */
+    readonly origin: 'documented' | 'generated';
+}
+/** A class, function or other definition. Its parameters, fields and member symbols are its children. */
+export interface SymbolNode extends NodeBase<SymbolKind> {
+    /** Unique within the file and safe in a URL hash. */
+    readonly anchor: string;
+    readonly line: number;
+    /** Highlighted declaration head. Empty for a type the scanner inferred from its members. */
+    readonly signatureHtml: string;
+    /** Keywords in front of the declaration, such as `export`, `static` or `async`. */
+    readonly modifiers: readonly string[];
+    /** Decorators, attributes and annotations, verbatim. */
+    readonly annotations: readonly string[];
+    readonly descriptionHtml: string;
+    readonly returns: ReturnInfo | null;
+    readonly tags: readonly DocTag[];
+    readonly example: SymbolExample | null;
+}
+/** Where an operation of an API takes a parameter from. */
+export type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/** What parameters and fields share: a declaration from the signature, a description from the doc comment. */
+interface Declaration {
+    readonly type: LinkedText | null;
+    /** Default value of a parameter, initializer of a field, value of an enum member. */
+    readonly defaultValue: string | null;
+    readonly optional: boolean;
+    readonly descriptionHtml: string;
+    /**
+     * The table column a declaration of a query stands for: the column a
+     * parameter is compared with or stored in, the column a result column
+     * selects. Set when the statement shows one and the scan has that table.
+     */
+    readonly column?: NodeRef;
+}
+/**
+ * A parameter of a function, of a type's constructor, of an API operation or
+ * of a query. `name` carries a variadic marker, as in `...rest`, or the
+ * marker of a SQL placeholder, as in `:map_id`.
+ */
+export interface ParameterNode extends NodeBase<'parameter'>, Declaration {
+    /** Set for a parameter of an API operation. */
+    readonly location?: ParameterLocation;
+}
+/**
+ * A field, property or enum member of a type, a property of a schema
+ * definition, a column of a table, or a column of the rows a query returns.
+ */
+export interface FieldNode extends NodeBase<'field'>, Declaration {
+    /**
+     * Further facts about the field, verbatim: annotations in code, constraints
+     * of a property such as `format: date`, constraints of a column such as
+     * `UNIQUE`, the expression behind a result column such as `COUNT(*)`.
+     */
+    readonly annotations: readonly string[];
+}
+/** One term of a glossary: a word of the project's language and what it means. */
+export interface TermNode extends NodeBase<'term'> {
+    /** Unique within the glossary and safe in a URL hash. */
+    readonly anchor: string;
+    /** Heading the glossary lists the term under, or `''`. */
+    readonly group: string;
+    readonly definitionHtml: string;
+    /** Words the glossary tells writers to replace with this term. */
+    readonly avoid: readonly string[];
+}
+/** One decision of a decision log: what was decided and why. */
+export interface DecisionNode extends NodeBase<'decision'> {
+    /** Unique within the log and safe in a URL hash. */
+    readonly anchor: string;
+    /** Number or id in front of the title, such as `3` or `ADR-0003`. `''` when the title has none. */
+    readonly id: string;
+    /** As written in the log, such as `accepted` or `superseded by 7`. `''` when the decision states none. */
+    readonly status: string;
+    /** As written in the log. `''` when the decision states none. */
+    readonly date: string;
+    readonly html: string;
+}
+/** One media type of a request body or a response, with the schema of its content. */
+export interface ApiContent {
+    /** Such as `application/json`. */
+    readonly mediaType: string;
+    /** The schema as a type expression, such as `Booking[]`. `null` when the document gives none. */
+    readonly schema: LinkedText | null;
+}
+/** The request body of an operation. */
+export interface ApiRequestBody {
+    readonly required: boolean;
+    readonly descriptionHtml: string;
+    readonly content: readonly ApiContent[];
+}
+/** One response of an operation. */
+export interface ApiResponse {
+    /** Status code or range as the document writes it: `200`, `4XX`, `default`. */
+    readonly status: string;
+    readonly descriptionHtml: string;
+    readonly content: readonly ApiContent[];
+}
+/**
+ * One operation of an OpenAPI document: a method on a path, or a webhook.
+ * `name` is the method and the path, as in `GET /bookings/{id}`. Its
+ * parameters are its children.
+ */
+export interface OperationNode extends NodeBase<'operation'> {
+    /** Unique within the document and safe in a URL hash. */
+    readonly anchor: string;
+    /** HTTP method in capitals. */
+    readonly method: string;
+    /** Path template, such as `/bookings/{id}`. For a webhook, its name. */
+    readonly urlPath: string;
+    /** `operationId` of the document, or `''`. */
+    readonly operationId: string;
+    /** Tags the operation is listed under. A webhook without tags is listed under `Webhooks`. */
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    /** One line of plain text, or `''`. */
+    readonly summary: string;
+    readonly descriptionHtml: string;
+    readonly requestBody: ApiRequestBody | null;
+    /** In the order of the document. */
+    readonly responses: readonly ApiResponse[];
+    /**
+     * The ways a caller can authenticate, each as the names of the security
+     * schemes it needs, joined with ` + `. Empty when the operation is open.
+     */
+    readonly security: readonly string[];
+}
+/**
+ * A named JSON Schema: the root schema of a file, an entry of its `$defs`, or
+ * an entry of `components.schemas` of an OpenAPI document. Its properties are
+ * its `field` children, nested ones under a dotted name such as `address.city`.
+ */
+export interface DefinitionNode extends NodeBase<'definition'> {
+    /** Unique within the file and safe in a URL hash. */
+    readonly anchor: string;
+    /** What the schema allows, as a type expression: `object`, `string[]`, `Cat | Dog`. */
+    readonly type: LinkedText | null;
+    readonly descriptionHtml: string;
+    /** Keywords that narrow the type, verbatim: `format: uuid`, `minimum: 0`. */
+    readonly constraints: readonly string[];
+    /** The values of an `enum` or a `const`, as JSON. Empty for every other schema. */
+    readonly values: readonly string[];
+    readonly deprecated: boolean;
+}
+/** A foreign key of a table. */
+export interface ForeignKey {
+    /** Name of the constraint, or `''`. */
+    readonly name: string;
+    /** Columns of this table, in key order. */
+    readonly columns: readonly string[];
+    /** Name of the referenced table, as the statement writes it. */
+    readonly table: string;
+    /** The referenced table, when the scan has it. */
+    readonly target: NodeRef | null;
+    /** Columns of the referenced table, in key order. Its primary key when the statement names none. */
+    readonly referencedColumns: readonly string[];
+    /** Action in capitals, such as `CASCADE` or `SET NULL`. `''` when the statement states none. */
+    readonly onDelete: string;
+    readonly onUpdate: string;
+}
+/** An index on a table. */
+export interface TableIndex {
+    readonly name: string;
+    /** Indexed columns or expressions, in index order. */
+    readonly columns: readonly string[];
+    readonly unique: boolean;
+}
+/** A table of a database schema. Its columns are its `field` children. */
+export interface TableNode extends NodeBase<'table'> {
+    /** Unique within the file and safe in a URL hash. */
+    readonly anchor: string;
+    readonly line: number;
+    readonly descriptionHtml: string;
+    /** Columns of the primary key, in key order. Empty for a table without one. */
+    readonly primaryKey: readonly string[];
+    readonly foreignKeys: readonly ForeignKey[];
+    readonly indexes: readonly TableIndex[];
+    /** Table constraints that are no key, verbatim: `UNIQUE (a, b)`, `CHECK (a < b)`. */
+    readonly constraints: readonly string[];
+    /** Table options in capitals: `WITHOUT ROWID`, `STRICT`, `VIRTUAL`. */
+    readonly options: readonly string[];
+}
+/**
+ * What running an entry of a query catalog does.
+ * - `read`: it returns rows and changes nothing, as `SELECT` does.
+ * - `write`: it changes rows or the schema, as `INSERT`, `UPDATE`, `DELETE` and `CREATE INDEX` do.
+ * - `control`: it changes the state of the transaction or the connection, as `BEGIN`, `COMMIT` and `PRAGMA` do.
+ */
+export type QueryEffect = 'read' | 'write' | 'control';
+/** A table an entry of a query catalog names, and what it does with it. */
+export interface QueryTable {
+    /** Name of the table, as the statement writes it. */
+    readonly name: string;
+    /** The table, when the scan has it. */
+    readonly target: NodeRef | null;
+    readonly access: 'read' | 'write';
+}
+/**
+ * One entry of a query catalog: the SQL of one `.sql` file, or of one named
+ * block of such a file. `name` is the name the code runs it by: the file name
+ * without `.sql`, or the name of the block. Its placeholders are its
+ * `parameter` children, and the columns of the rows it returns are its
+ * `field` children.
+ */
+export interface QueryNode extends NodeBase<'query'> {
+    /** Unique within the catalog and safe in a URL hash. */
+    readonly anchor: string;
+    /** Path of the file the entry is in, relative to the scanned root. */
+    readonly sourcePath: string;
+    readonly line: number;
+    readonly effect: QueryEffect;
+    /** The keywords that open the statement, in capitals: `SELECT`, `INSERT`, `BEGIN IMMEDIATE`. */
+    readonly verb: string;
+    /** The comment above the statement. `''` for an entry without one. */
+    readonly descriptionHtml: string;
+    /** The highlighted SQL, as the file writes it. */
+    readonly sqlHtml: string;
+    /** The tables the SQL names, each once per access, in the order they first appear. */
+    readonly tables: readonly QueryTable[];
+}
+/** Where a plan, a phase or a task stands, in the order task-manager moves it through. */
+export declare const TASK_STATUSES: readonly ['open', 'in-progress', 'in-review', 'completed', 'blocked'];
+/** One of {@link TASK_STATUSES}. */
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+/** How urgent a plan, a phase or a task is, most urgent first. */
+export declare const TASK_PRIORITIES: readonly ['critical', 'high', 'medium', 'low'];
+/** One of {@link TASK_PRIORITIES}. */
+export type TaskPriority = (typeof TASK_PRIORITIES)[number];
+/** What every plan, phase and task of the task tree states in its frontmatter. */
+interface TrackedFacts {
+    readonly status: TaskStatus;
+    readonly priority: TaskPriority;
+    /** One line of plain text. */
+    readonly summary: string;
+    /** Names of the plans or phases, or ids of the tasks, this one waits for, as the file writes them. */
+    readonly dependsOn: readonly string[];
+}
+/**
+ * A plan of the task tree: `<plan>/<plan>.md`. Its phases are its children,
+ * and the decision log of its `decisions/` folder when it has one.
+ * `name` is the plan's folder name, `title` its title.
+ */
+export interface PlanNode extends NodeBase<'plan'>, FileFacts, TrackedFacts {
+}
+/** A phase of a plan: `<plan>/<phase>/<phase>.md`. Its tasks are its children. */
+export interface PhaseNode extends NodeBase<'phase'>, FileFacts, TrackedFacts {
+    /** Whether its tasks can run side by side. */
+    readonly parallel: boolean;
+}
+/** One task of a phase: `<phase>/tasks/<id>.md`, shown as an entry on the page of its phase. `name` is its title. */
+export interface TaskNode extends NodeBase<'task'>, TrackedFacts {
+    /** Unique within the phase and safe in a URL hash. */
+    readonly anchor: string;
+    /** Such as `TASK-006`. */
+    readonly id: string;
+    /** Path of the task file, relative to the scanned root. */
+    readonly sourcePath: string;
+    /** The package the task changes, as the file names it. */
+    readonly package: string;
+    /** From 1 for small to 5 for large. `null` when the file states none. */
+    readonly complexity: number | null;
+    readonly html: string;
+}
+/** A file node of any kind. */
+export type AnyFileNode = FileNode | ApiNode | DatabaseNode | PlanNode | PhaseNode;
+/** A node of any kind. */
+export type GraphNode = SectionNode | FolderNode | AnyFileNode | SourceNode | SymbolNode | TermNode | DecisionNode | OperationNode | DefinitionNode | TableNode | QueryNode | TaskNode | ParameterNode | FieldNode;
+/** An entry of any kind. */
+export type EntryNode = SymbolNode | TermNode | DecisionNode | OperationNode | DefinitionNode | TableNode | QueryNode | TaskNode;
+/** Tells a symbol node from the others. */
+export declare function isSymbolNode(node: GraphNode): node is SymbolNode;
+/** Tells an entry node, a symbol included, from the others. */
+export declare function isEntryNode(node: GraphNode): node is EntryNode;
+/** Tells a node of a file with a page from the others. */
+export declare function isFileNode(node: GraphNode): node is AnyFileNode;
+/** Kinds of an entry that is described in markdown and can have parameters or fields. */
+export type DescribedNode = SymbolNode | OperationNode | DefinitionNode | TableNode | QueryNode;
+/**
+ * Tells the entries with a `descriptionHtml` from the others.
+ *
+ * @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];
+/** What the bundle says about its own making. `generatedAt` is an ISO 8601 timestamp. */
+export interface BundleMeta {
+    readonly title: string;
+    readonly generatedAt: string;
+    readonly generator: string;
+}
+/** Version of the layout of {@link SemanticIndex}. A reader skips an index of another version. */
+export declare const SEMANTIC_FORMAT = 3;
+/**
+ * What a reader needs to search by meaning: a small text embedding model, one
+ * vector per searchable node and the words of each node. An **embedding** is a
+ * list of numbers that stands for the meaning of a text. Texts with a similar
+ * meaning get similar numbers, so `vessel` is found by a search for `ship`.
+ *
+ * The model is a table with one vector per word. A contextual model computed
+ * each vector in advance, from the word on its own. The vector of a text is
+ * the mean of the vectors of its words, so a reader computes it without a
+ * neural network and without a server.
+ */
+export interface SemanticIndex {
+    readonly format: typeof SEMANTIC_FORMAT;
+    /** Name of the embedding model, for display. */
+    readonly model: string;
+    /** Length of every vector. */
+    readonly dimensions: number;
+    /** The words of the model, joined with `\n`. The line number of a word is its row in `vocabularyVectors`. */
+    readonly vocabulary: string;
+    /** Base64 of the model table: one row of `dimensions` values per word, each value in four bits. */
+    readonly vocabularyVectors: string;
+    /** The nodes that have a vector, in the order of `nodeVectors`. */
+    readonly nodes: readonly NodeRef[];
+    /** Base64 of signed bytes: one vector of length 1 per node, scaled to the range of a signed byte. */
+    readonly nodeVectors: string;
+    /** Every word that carries meaning in the name or the text of a node, each once, joined with `\n`. */
+    readonly words: string;
+    /**
+     * For each node of `nodes`, the words of its name and the further words of
+     * its text, as line numbers in `words`. A one-word query is compared with
+     * these words, because the mean of a whole text hides a single word.
+     */
+    readonly nodeWords: readonly (readonly [name: readonly number[], text: readonly number[]])[];
+}
+/**
+ * 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.
+ *
+ * The bundle is a graph. A **node** is one thing the site shows: a folder, a
+ * skill, a document, a class, a parameter, a glossary term, an API operation,
+ * a database table, a query. `parent` puts every node in one tree, and that
+ * tree is the navigation. An **edge** is any other relation between two nodes,
+ * such as "this parameter has that class as its type".
+ */
+export interface DocsBundle {
+    readonly meta: BundleMeta;
+    /** A node comes after its parent, and siblings are in display order. */
+    readonly nodes: readonly GraphNode[];
+    readonly edges: readonly Edge[];
+    /** Left out when the site was generated without embeddings. */
+    readonly semantic?: SemanticIndex;
+}
+/** Where a node is shown: a page, and for an entry an anchor on that page. */
+export interface Route {
+    /** Slugs from the section down, joined with `/` and not URL-encoded: `code/src/app.ts`. */
+    readonly path: string;
+    readonly hash?: string;
+}
+/** The part of a node that decides its route. */
+export interface Routable {
+    readonly kind: NodeKind;
+    readonly name: string;
+    readonly parent: NodeRef | null;
+    readonly slug?: string;
+    readonly anchor?: string;
+}
+/**
+ * DOM id and URL hash of an entry on the page of its file: `symbol:App.run`,
+ * `term:lane`, `decision:3-use-hash-routes`, `table:Booking`, `query:list_bookings`. The prefix keeps
+ * entry anchors apart from heading anchors.
+ */
+export declare function entryAnchor(kind: EntryKind, anchor: string): string;
+/**
+ * Route of a node. Sections, folders and files are pages. An entry is an
+ * anchor on the page of its file, and a parameter or field shares the route
+ * of its symbol. The scanner and the web app both use this function.
+ */
+export declare function routeOf(nodes: readonly Routable[], ref: NodeRef): Route;
+/** Link to a route from inside the generated page: `#/code/src/app.ts#symbol:App.run`. */
+export declare function hrefOf(route: Route): string;
+/** Id of the `<script type="application/json">` element that holds the bundle. */
+export declare const DATA_ELEMENT_ID = "analyze-data";
+/** Id of the element the app mounts into. */
+export declare const MOUNT_ELEMENT_ID = "analyze-root";
+/** `localStorage` key of the reader's color mode. The template reads it before first paint. */
+export declare const COLOR_MODE_STORAGE_KEY = "analyze:color-mode";
+/** Template marker the CLI replaces with the serialized bundle. Nothing in the web bundle imports it, so the marker stays out of it. */
+export declare const DATA_PLACEHOLDER = "__ANALYZE_DATA__";
+/** Template marker the CLI replaces with the title of the site. Like {@link DATA_PLACEHOLDER}, nothing in the web bundle imports it. */
+export declare const TITLE_PLACEHOLDER = "__ANALYZE_TITLE__";