@venn-lang/lsp 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,722 @@
+import { AstNode, DecoDecl, Document, Expr, FragmentDecl, Problem, Type } from "@venn-lang/core";
+import { AstNode as AstNode$1, LangiumDocument, LangiumDocuments, URI } from "langium";
+import { ActionDefinition, MatcherDefinition, PluginDefinition } from "@venn-lang/sdk";
+import { TypeSpec } from "@venn-lang/types";
+import { CompletionList, CompletionParams, Connection, DefinitionParams, DocumentFormattingParams, DocumentHighlight, DocumentHighlightParams, DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingParams, DocumentRangeFormattingParams, DocumentSymbol, Hover, HoverParams, Location, LocationLink, Position, PrepareRenameParams, Range, ReferenceParams, RenameParams, SignatureHelp, SignatureHelpOptions, SignatureHelpParams, TextEdit, WorkspaceEdit } from "vscode-languageserver";
+import { AbstractSemanticTokenProvider, CompletionProvider, DefaultSharedModuleContext, DefinitionProvider, DocumentHighlightProvider, DocumentSymbolProvider, Formatter, HoverProvider, LangiumServices, LangiumSharedServices, ReferencesProvider, RenameProvider, SemanticTokenAcceptor, SignatureHelpProvider } from "langium/lsp";
+//#region src/catalog/catalog.types.d.ts
+/** One type a plugin publishes: `http.Request`, and the shape behind it. */
+interface TypeEntry {
+  namespace: string;
+  name: string;
+  package: string;
+  spec: TypeSpec;
+}
+/** One action, with the package that contributes it. */
+interface ActionEntry {
+  namespace: string;
+  name: string;
+  package: string;
+  action: ActionDefinition;
+}
+/** One matcher, with the package that contributes it. */
+interface MatcherEntry {
+  name: string;
+  package: string;
+  matcher: MatcherDefinition;
+}
+/**
+ * Everything the editor needs to resolve, list and describe stdlib symbols.
+ * The grammar cannot tell `http.post` from `myHelper.foo`; this catalogue can.
+ */
+interface SymbolCatalog {
+  namespaces(): readonly string[];
+  packages(): readonly string[];
+  hasNamespace(namespace: string): boolean;
+  actionsIn(namespace: string): readonly ActionEntry[];
+  action(namespace: string, name: string): ActionEntry | undefined;
+  /** The types that namespace publishes: what `http.` offers besides verbs. */
+  typesIn(namespace: string): readonly TypeEntry[];
+  matchers(): readonly MatcherEntry[];
+  matcher(name: string): MatcherEntry | undefined;
+  namespaceOfPackage(pkg: string): string | undefined;
+  /** Every package contributing this namespace: the `use` options to offer. */
+  packagesFor(namespace: string): readonly string[];
+}
+//#endregion
+//#region src/catalog/build-catalog.d.ts
+/**
+ * Index the loaded plugins so completion, hover and tokens can look symbols up.
+ *
+ * @param plugins The plugin definitions loaded for the workspace.
+ * @returns A read-only view over their actions, matchers and published types.
+ */
+declare function buildCatalog(plugins: readonly PluginDefinition[]): SymbolCatalog;
+//#endregion
+//#region src/types/type-service.d.ts
+/** What inference found for one document: its type errors and every node's type. */
+interface DocumentTypes {
+  problems: readonly Problem[];
+  types: ReadonlyMap<AstNode, Type>;
+  /**
+   * Per string literal, the expression inference parsed from each `${…}`. The
+   * document's own tree stops at the string, so these are the only nodes the
+   * editor can reach for code written inside one.
+   */
+  slots: ReadonlyMap<AstNode, readonly (Expr | undefined)[]>;
+}
+/**
+ * Type information for the workspace, computed once per parse of a document.
+ *
+ * Inference walks a whole file, and several features want its result:
+ * diagnostics on every edit, hover on every mouse move. Without a shared cache
+ * the same file is re-checked many times per keystroke; with it, a file is
+ * checked once when it changes and every reader is served from memory.
+ */
+interface TypeService {
+  /** Everything inference knows about this document, cached until it is reparsed. */
+  of(document: LangiumDocument): DocumentTypes;
+  /** What is already cached, or undefined, for readers that must not block. */
+  peek(document: LangiumDocument): DocumentTypes | undefined;
+  /** Forget a document: it was deleted, or its folder was closed. */
+  forget(uri: string): void;
+}
+//#endregion
+//#region src/workspace/import-resolver.d.ts
+/**
+ * Reads the nearest `venn.toml` and answers the project-level questions that
+ * depend on it: where an import points, and how this project formats.
+ */
+interface ImportResolver {
+  resolve(spec: string, base: URI): URI;
+  /** The `[paths]` aliases visible from a file, and the folder each maps to. */
+  aliases(base: URI): Record<string, URI>;
+  /** The raw `[format]` table, for {@link formatOptionsFrom}. */
+  formatSettings(base: URI): Record<string, unknown>;
+  /** Every variable the project declares: `[env.*]` and the dotenv files. */
+  env(base: URI): Record<string, Record<string, string>>;
+  /** The comment written above each key in `venn.toml`, as its documentation. */
+  envDocs(base: URI): Record<string, string>;
+  /**
+   * What an installed package publishes, derived at install into `target/types/`.
+   *
+   * Read here rather than derived here: deriving means loading the TypeScript
+   * compiler and reading a package's whole declaration graph, which is a second
+   * of work and cannot happen on a keystroke. Nothing installed, or nothing
+   * derived yet, means an imported name is `dynamic`, which is the truth about
+   * it and not a failure.
+   */
+  packageTypes(base: URI, packages: readonly string[]): Map<string, Record<string, TypeSpec>>;
+}
+/**
+ * Relative specifiers resolve against the importing file; `#alias/…` resolves
+ * through the nearest `venn.toml`, searched upwards and cached per directory.
+ */
+declare function createImportResolver(): ImportResolver;
+//#endregion
+//#region src/services/lsp.types.d.ts
+/** The extra services Venn adds on top of Langium's LSP stack. */
+interface VennAddedServices {
+  catalog: SymbolCatalog;
+  imports: ImportResolver;
+  types: TypeService;
+}
+/** The full language services for Venn. */
+type VennServices = LangiumServices & VennAddedServices;
+//#endregion
+//#region src/completion/completion.d.ts
+/**
+ * Context-aware completion, driven by the text before the cursor.
+ *
+ * `contextAt` classifies the cursor, and each context has exactly one source of
+ * items: a namespace's verbs, an options map's keys, the names in scope.
+ */
+declare class VennCompletionProvider implements CompletionProvider {
+  private readonly catalog;
+  private readonly documents;
+  private readonly imports;
+  private readonly types;
+  constructor(services: VennServices);
+  getCompletion(document: LangiumDocument, params: CompletionParams): Promise<CompletionList>;
+  /**
+   * What follows a dot. A name the file bound wins over a plugin namespace, the
+   * same rule the evaluator and the highlighter follow, so a variable named
+   * `auth` completes as its own value even when `@venn-lang/auth` is loaded.
+   */
+  private afterDot;
+  /**
+   * What follows a dot no name can precede: `(1234.567).`, `f(x).`, `xs[0].`.
+   * The receiver has no text to look up, so its inferred type answers.
+   */
+  private afterExpression;
+  private env;
+  private itemsFor;
+  /**
+   * Every name in scope, with an imported one drawn as what it really is.
+   *
+   * `namesInScope` reads this file's tree, so it can say only that a name came
+   * from an import. Its kind lives in the file it came from, which is in reach
+   * here, so an imported fragment is drawn as a fragment rather than as an
+   * anonymous binding.
+   */
+  private scopeNames;
+  /** What each name this file imported was declared as, in the file it came from. */
+  private publishedTo;
+  /**
+   * `run ▮`: the fragments this file declared, and the ones it imported.
+   *
+   * `run` can only invoke a fragment, so an imported name is offered only once
+   * the file it came from confirms it is one.
+   */
+  private fragments;
+  /** `id: ▮`: the language's own types, this file's, and its imports'. */
+  private typeNames;
+  /**
+   * The last two shapes a cursor can be in before it is simply a new statement:
+   * inside a call's brackets, or after a matcher word.
+   */
+  private fallback;
+  /**
+   * A fresh statement: the names already bound, then the words that open one.
+   *
+   * Calling a function is itself a statement, so bound names belong here. They
+   * come first because the language's own vocabulary is always available.
+   */
+  private opening;
+  /**
+   * `const r = http.get "u" ▮`: a bracket-less call bound to a name.
+   *
+   * The `argument` context reads the head of the line, which here is `const`
+   * rather than the verb. Same words deserve the same help, so it is caught
+   * separately.
+   */
+  private afterBareCall;
+  /** What may go in this position: a value, or the options map that ends the call. */
+  private dueAt;
+  /** `expect res contains ▮`: the value the check is waiting for. */
+  private afterMatcher;
+  /**
+   * `saudacao(▮)`, `fmt.json(x, ▮)`: inside a bracketed call.
+   *
+   * Reached last, before offering a fresh statement. Everything more specific
+   * (a dot, an options key, a bare argument) has already had its turn, so what
+   * is left inside brackets is a value.
+   */
+  private inBrackets;
+  /**
+   * `http.on ▮`: what the program already holds, before what the stdlib offers.
+   * A name the text took for a verb but the language does not know is not an
+   * argument position at all, so that falls back to a fresh statement.
+   */
+  private argument;
+  /** What the program holds that could go here, the fitting ones first. */
+  private valuesFor;
+  private decorators;
+  private paths;
+  private exports;
+}
+//#endregion
+//#region src/completion/completion.types.d.ts
+/**
+ * Where the cursor sits, and from which character the completion should
+ * replace. Without that range VS Code falls back to its own word rules, which
+ * break on `@` and `/`: accepting `@venn-lang/http` inside `"@venn-lang/"` would paste
+ * the prefix twice.
+ */
+type CompletionContext = {
+  kind: "package";
+  from: number;
+} | {
+  kind: "modulePath";
+  from: number;
+  partial: string;
+} | {
+  kind: "importName";
+  from: number;
+  path?: string;
+} | {
+  kind: "action";
+  from: number;
+  receiver: string;
+} | {
+  kind: "member";
+  from: number;
+} | {
+  kind: "annotation";
+  from: number;
+} | {
+  kind: "fragment";
+  from: number;
+} | {
+  kind: "matcher";
+  from: number;
+} | {
+  kind: "optionKey";
+  from: number;
+  target: string;
+} | {
+  kind: "argument";
+  from: number;
+  target: string;
+} | {
+  kind: "typeName";
+  from: number;
+} | {
+  kind: "statement";
+  from: number;
+};
+/** The text the classifier reads: the current line, and everything before the cursor. */
+interface CursorText {
+  /** The current line up to the cursor; `from` is a column on this line. */
+  prefix: string;
+  /** The whole current line. */
+  line: string;
+  /** The whole document up to the cursor; an options map spans lines. */
+  before: string;
+}
+//#endregion
+//#region src/completion/context.d.ts
+/**
+ * Classify the cursor from the text before it. String contexts are tested first:
+ * a module path like `#shared/auth.vn` also looks like `namespace.action`.
+ *
+ * @param text The line, the prefix up to the cursor and the document before it.
+ * @returns The narrowest context that matches, or `statement` when none does.
+ */
+declare function contextAt(text: CursorText): CompletionContext;
+//#endregion
+//#region src/completion/module-paths.d.ts
+interface PathArgs {
+  partial: string;
+  base: URI;
+  imports: ImportResolver;
+}
+/**
+ * What may follow `from "`: a `#alias/…` path from `venn.toml`, or a relative
+ * path to a sibling `.vn` file. The `#` only marks an alias; plain relative
+ * paths need no prefix.
+ *
+ * @returns Path strings ready to insert, without the surrounding quotes.
+ */
+declare function modulePaths(args: PathArgs): string[];
+//#endregion
+//#region src/deco/deco.types.d.ts
+/**
+ * One decorator a `@name` could mean here: a `deco` some file declares, or one
+ * the language ships with.
+ *
+ * `decorates` is in the language's own words (`Fn`, `Flow`, `Step`), never a
+ * node type. What a decorator applies to is part of its signature, so reading
+ * one costs nobody a lesson in the compiler's vocabulary.
+ */
+interface DecoInfo {
+  name: string;
+  /** The kinds it may sit on. Empty means it constrains nothing. */
+  decorates: readonly string[];
+  /** The line a hover fences: `pub deco retry(target: Flow, times: number)`. */
+  signature: string;
+  doc?: string;
+  /** The declaration, when a `.vn` declares it: where go-to-definition lands. */
+  decl?: DecoDecl;
+  /** The document holding {@link decl}. Absent for a built-in. */
+  document?: LangiumDocument;
+}
+//#endregion
+//#region src/deco/builtin-decos.d.ts
+/**
+ * The decorators every file has without asking: the ones the runtime ships.
+ * They are read through the same shape a declared `deco` produces, so the
+ * editor holds one notion of what a decorator is rather than two.
+ */
+declare function builtinDecos(): DecoInfo[];
+//#endregion
+//#region src/deco/decos-in-scope.d.ts
+/** What a file needs consulted before it can say what `@name` means. */
+interface DecoScope {
+  document: LangiumDocument;
+  documents: LangiumDocuments;
+  imports: ImportResolver;
+}
+/**
+ * Every decorator a `@name` written in this file could mean: the ones the
+ * language ships with, the `pub deco`s it imported, and the `deco`s it declares
+ * itself.
+ *
+ * Later wins, on the same rule the runtime already follows for plugins: the
+ * built-ins are a stdlib, not a reserved word list, so a file that declares its
+ * own `deco retry` means its own.
+ */
+declare function decosInScope(scope: DecoScope): Promise<DecoInfo[]>;
+/** The decorator a `@name` resolves to, or nothing when no decorator carries it. */
+declare function decoNamed(name: string, scope: DecoScope): Promise<DecoInfo | undefined>;
+//#endregion
+//#region src/definition/definition.d.ts
+/** Ctrl+Click: `run` fragments (local or imported), bindings, and imported files. */
+declare class VennDefinitionProvider implements DefinitionProvider {
+  private readonly documents;
+  private readonly imports;
+  constructor(services: VennServices);
+  getDefinition(document: LangiumDocument, params: DefinitionParams): Promise<LocationLink[] | undefined>;
+  /** `"${base}/users"`: the name inside the placeholder is a real reference. */
+  private interpolated;
+  private resolve;
+  private decorator;
+  private fragment;
+}
+//#endregion
+//#region src/docs/doc.types.d.ts
+/** One documented parameter. */
+interface DocParam {
+  name: string;
+  text: string;
+}
+/**
+ * A parsed documentation block: the `##` lines above a declaration, or its
+ * `@doc("…")` annotation (§08). Summary and every field are markdown.
+ */
+interface DocBlock {
+  summary: string;
+  params: DocParam[];
+  returns?: string;
+  examples: string[];
+  deprecated?: string;
+}
+//#endregion
+//#region src/docs/parse-doc.d.ts
+/** Split doc lines into a summary plus `@param` / `@returns` / `@example` / `@deprecated`. */
+declare function parseDoc(lines: readonly string[]): DocBlock;
+//#endregion
+//#region src/docs/read-doc.d.ts
+/**
+ * The documentation attached to a declaration: a `##` block directly above it,
+ * or its `@doc("…")` annotation (§08). `##` wins when both are present.
+ *
+ * @returns The parsed block, or `undefined` when the declaration has neither.
+ */
+declare function readDoc(document: LangiumDocument, node: AstNode): DocBlock | undefined;
+//#endregion
+//#region src/docs/render-doc.d.ts
+/**
+ * Render a doc block. The prose keeps its own paragraph rhythm; the tagged
+ * sections sit below a rule so they read as a distinct band, not as more prose.
+ *
+ * @returns Markdown, or `undefined` when the block has nothing worth showing.
+ */
+declare function renderDoc(doc: DocBlock | undefined): string | undefined;
+//#endregion
+//#region src/document/exported-names.d.ts
+/** A name a module publishes, and which kind of thing it is. */
+interface ExportedName {
+  name: string;
+  /** `fragment`, `fn` or `deco`: what the editor draws it as. */
+  origin: string;
+}
+/**
+ * The names a module marks `pub`: everything another file is allowed to import.
+ * A `deco` crosses files like a fragment or a function does.
+ *
+ * The kind travels with the name because the two are read together everywhere:
+ * an `import { … }` list draws a fragment apart from a function, and `run`
+ * accepts only one of them.
+ */
+declare function exportedNames(document: Document): ExportedName[];
+//#endregion
+//#region src/document/find-binding.d.ts
+/** The node that binds `name`, searched from `from` outwards to the document. */
+declare function findBinding(from: AstNode, name: string): AstNode | undefined;
+/** The fragment a document declares under `name`. */
+declare function findFragment(document: Document, name: string): FragmentDecl | undefined;
+//#endregion
+//#region src/document/imported-names.d.ts
+/** The names a document pulls in via `import { a, b } from "…"`. */
+declare function importedNames(document: Document): string[];
+//#endregion
+//#region src/document/resolve-fragment.d.ts
+/** Where a fragment lives. `decl` is absent when the file could not be read. */
+interface FragmentLocation {
+  uri: URI;
+  decl?: FragmentDecl;
+  document?: LangiumDocument;
+}
+interface ResolveFragmentArgs {
+  name: string;
+  document: LangiumDocument;
+  documents: LangiumDocuments;
+  imports: ImportResolver;
+}
+/** Find a fragment: declared in this file, or followed through the `import` naming it. */
+declare function resolveFragment(args: ResolveFragmentArgs): Promise<FragmentLocation | undefined>;
+//#endregion
+//#region src/formatting/formatter.d.ts
+/**
+ * Formatting runs through `@venn-lang/core`, so the editor and `venn fmt` produce
+ * byte-identical output. Project settings come from `[format]` in `venn.toml`;
+ * the editor's own indent settings fill in what the project left unset.
+ */
+declare class VennFormatter implements Formatter {
+  private readonly imports;
+  constructor(services: VennServices);
+  /** Re-indent the line as soon as a block is closed. */
+  get formatOnTypeOptions(): DocumentOnTypeFormattingOptions;
+  formatDocument(document: LangiumDocument, params: DocumentFormattingParams): TextEdit[];
+  formatDocumentRange(document: LangiumDocument, params: DocumentRangeFormattingParams): TextEdit[];
+  formatDocumentOnType(document: LangiumDocument, params: DocumentOnTypeFormattingParams): TextEdit[];
+  private rewrite;
+}
+//#endregion
+//#region src/hover/hover.d.ts
+/**
+ * Rich markdown hover: actions, matchers, fragments, bindings and keywords.
+ *
+ * Which token the cursor sits on decides the answer, so every branch checks the
+ * CST property it belongs to rather than the enclosing node alone.
+ */
+declare class VennHoverProvider implements HoverProvider {
+  private readonly catalog;
+  private readonly documents;
+  private readonly imports;
+  private readonly types;
+  constructor(services: VennServices);
+  getHoverContent(document: LangiumDocument, params: HoverParams): Promise<Hover | undefined>;
+  /** Inside `"${…}"` the name is code, so it hovers like code, not like text. */
+  private inString;
+  /**
+   * A member read off the node rather than off the text.
+   *
+   * The dotted-path resolver can only name a chain of identifiers, so it has
+   * nothing to say about `(1234.567).round` or `f(x).len`. The receiver's
+   * inferred type is right there on the tree, so read it from there instead.
+   */
+  private member;
+  /** The one resolver every place uses, so a name reads the same anywhere. */
+  private resolve;
+  /** Which of this file's functions wait for something, for the signature to say so. */
+  private waits;
+  /** `env.NAME` is not a variable anyone declared here; `venn.toml` declares it. */
+  private envVar;
+  private describe;
+  private symbol;
+  /**
+   * A name in an `import` list, or the specifier it comes from.
+   *
+   * The list is the one place a name is neither declared nor used, so no other
+   * branch reaches it. It is also where a reader is deciding whether they want
+   * the thing at all, which is where a hover is worth the most.
+   */
+  private imported;
+  /**
+   * The verb of a call written as a statement.
+   *
+   * Usually a plugin's, as in `http.get`. But `target.wrap(…)` is a method on a
+   * value, and the parser reads it as a call whose target is text, so the
+   * member chain a hover normally walks does not exist. Resolving from that
+   * text puts it back, which is why hovering `target` inside a `deco` answers.
+   */
+  private callTarget;
+  /**
+   * A dotted path written plainly: `fmt.json`, `xs.map`, `range`. The segment
+   * under the cursor decides what is described: the namespace, or its verb.
+   */
+  private pathHover;
+  private declared;
+  /**
+   * `@name`: whatever defines it. A `deco` this file declares or imported, or
+   * a built-in; either way the same text a hover on the `deco` itself gives.
+   */
+  private decorator;
+  private fragment;
+}
+//#endregion
+//#region src/references/document-highlight.d.ts
+/**
+ * The other places the name under the cursor appears, marked in this file.
+ *
+ * Only this file, whatever the symbol's reach: highlighting is about the page
+ * being read. Where the name is introduced is drawn apart from where it is
+ * used, which is the quickest way to see that a value is written once and read
+ * four times, or written twice, which is usually the bug being looked for.
+ */
+declare class VennDocumentHighlightProvider implements DocumentHighlightProvider {
+  getDocumentHighlight(document: LangiumDocument, params: DocumentHighlightParams): DocumentHighlight[];
+}
+//#endregion
+//#region src/references/symbol.types.d.ts
+/**
+ * What a name under the cursor turns out to be.
+ *
+ * The kinds differ in one thing that decides everything downstream: how far the
+ * name reaches. A `fragment`, a `deco` and a `pub fn` cross files, so finding
+ * every use means reading the workspace. A `const`, a parameter or a loop
+ * variable is bound in one place in one file, and a name spelled the same
+ * anywhere else is a different name: following it out of the file would report
+ * strangers as references.
+ */
+type SymbolKind$1 = "fragment" | "deco" | "fn" | "type" | "binding" | "external";
+interface FoundSymbol {
+  kind: SymbolKind$1;
+  name: string;
+  /**
+   * The node that binds it, when the kind is file-scoped. Two `const`s of the
+   * same name in one file are two symbols, and this is what tells them apart.
+   */
+  binding?: AstNode;
+}
+/** One place a name appears, named by the property of the node that holds it. */
+interface Occurrence {
+  node: AstNode;
+  property: string;
+  /** For a list-valued property: the names inside `import { a, b }`. */
+  index?: number;
+  /** Whether this is where the name is introduced, rather than used. */
+  declaration: boolean;
+}
+//#endregion
+//#region src/references/find-occurrences.d.ts
+/** One document's share of the answer. */
+interface FoundIn {
+  uri: string;
+  occurrences: readonly Occurrence[];
+}
+/**
+ * Every place a symbol appears, in the file that asked and in the workspace
+ * when the symbol reaches that far.
+ *
+ * A file-scoped binding is never searched for elsewhere. That is not an
+ * optimisation: a `const` named `user` next door is a different `user`, and
+ * offering it as a reference sends the reader somewhere unrelated.
+ */
+declare function findOccurrences(args: {
+  symbol: FoundSymbol;
+  document: LangiumDocument;
+  documents: LangiumDocuments;
+}): FoundIn[];
+//#endregion
+//#region src/references/occurrences.d.ts
+/**
+ * Every place one symbol appears in one document.
+ *
+ * One walk, one answer, whatever the caller wants it for: "find all references"
+ * shows them, the editor highlights them, and rename rewrites them. Three
+ * separate readings of the tree would be three chances to disagree.
+ */
+declare function occurrencesIn(args: {
+  root: Document;
+  symbol: FoundSymbol;
+}): Occurrence[];
+//#endregion
+//#region src/references/references.d.ts
+/**
+ * Shift+F12: every place a name is used.
+ *
+ * Langium's own provider resolves cross-references the grammar declares, and
+ * this grammar declares none: a `run` target is a string, a `@name` is a string,
+ * and which `const` a `Ref` means is worked out by walking scopes. So the answer
+ * has to be worked out the same way the checker and the evaluator work it out,
+ * which is what this shares with them.
+ */
+declare class VennReferencesProvider implements ReferencesProvider {
+  private readonly documents;
+  constructor(services: VennServices);
+  findReferences(document: LangiumDocument, params: ReferenceParams): Location[];
+}
+//#endregion
+//#region src/references/symbol-at.d.ts
+/**
+ * The symbol a position names, or nothing when it names none.
+ *
+ * Read from the token under the cursor rather than from the node containing it:
+ * one node often carries two names (`import { a, b }` is a single node, and so
+ * is `run login("x")`), and the answer depends on which word was clicked.
+ */
+declare function symbolAt(document: LangiumDocument, position: Position): FoundSymbol | undefined;
+//#endregion
+//#region src/rename/rename.d.ts
+/**
+ * F2: rename a name wherever it means this one.
+ *
+ * Reads the same occurrences "find all references" reports, so the two cannot
+ * disagree. A rename that silently misses a use is worse than no rename at all.
+ */
+declare class VennRenameProvider implements RenameProvider {
+  private readonly documents;
+  constructor(services: VennServices);
+  rename(document: LangiumDocument, params: RenameParams): WorkspaceEdit | undefined;
+  prepareRename(document: LangiumDocument, params: PrepareRenameParams): Range | undefined;
+  /**
+   * The symbol under the cursor, when it is one this can rewrite.
+   *
+   * A built-in decorator has no source to rewrite, and changing one use of it
+   * would break the program while looking like a rename.
+   */
+  private wanted;
+}
+//#endregion
+//#region src/semantic/semantic-tokens.d.ts
+/**
+ * Colours a `.vn` the way §23 specifies. The grammar cannot tell `http.post`
+ * from `myHelper.foo`, since both are `ActionCall`, so the catalog decides.
+ * Each pass owns one family of tokens, and a node matches at most one of them.
+ */
+declare class VennSemanticTokenProvider extends AbstractSemanticTokenProvider {
+  private readonly catalog;
+  constructor(services: VennServices);
+  protected override highlightElement(node: AstNode$1, acceptor: SemanticTokenAcceptor): void;
+}
+//#endregion
+//#region src/server/start-server.d.ts
+/**
+ * Start the Venn language server on an established connection. This is the one
+ * wiring shared by the standalone `venn-lsp` binary and the VS Code extension.
+ *
+ * @param connection An LSP connection the caller has already created.
+ */
+declare function startVennServer(connection: Connection): void;
+//#endregion
+//#region src/services/venn-lsp-module.d.ts
+/**
+ * Build the Venn language services on top of Langium's LSP stack. Registering
+ * the validator and warming the type cache happen here, so a caller only has to
+ * supply a connection and start the server.
+ *
+ * @param context Langium's shared module context: a connection and a file system.
+ * @returns The shared Langium services, and the Venn services built on them.
+ */
+declare function createVennLspServices(context: DefaultSharedModuleContext): {
+  shared: LangiumSharedServices;
+  Venn: VennServices;
+};
+//#endregion
+//#region src/signature/signature-help.d.ts
+/**
+ * What the call being typed takes, one argument at a time.
+ *
+ * The space is a trigger character because Venn's calls have no brackets to
+ * hang one off: `http.on ` is already a call with an argument due. Waiting for
+ * a `(` that never comes is how a language ends up unable to explain itself.
+ */
+declare class VennSignatureHelpProvider implements SignatureHelpProvider {
+  private readonly catalog;
+  private readonly types;
+  constructor(services: VennServices);
+  get signatureHelpOptions(): SignatureHelpOptions;
+  provideSignatureHelp(document: LangiumDocument, params: SignatureHelpParams): SignatureHelp | undefined;
+  /** `saudacao(▮)`: a call with brackets, wherever its callee was declared. */
+  private forParens;
+  /** `expect res contains ▮`: the value the check is waiting for. */
+  private forMatcher;
+  /** `http.on api handler`: a verb and its bare arguments, bound or not. */
+  private forAction;
+}
+//#endregion
+//#region src/symbols/document-symbols.d.ts
+/** The outline: flows with their steps and groups, plus fragments and resources. */
+declare class VennDocumentSymbolProvider implements DocumentSymbolProvider {
+  getSymbols(document: LangiumDocument): DocumentSymbol[];
+}
+//#endregion
+//#region src/validation/check-validator.d.ts
+/** Wire the runtime's static check (VN2003/4/5) into the editor's diagnostics. */
+declare function registerVennChecks(services: VennServices): void;
+//#endregion
+export { type ActionEntry, type CompletionContext, type DecoInfo, type DecoScope, type DocBlock, type DocParam, type FragmentLocation, type ImportResolver, type MatcherEntry, type SymbolCatalog, type VennAddedServices, VennCompletionProvider, VennDefinitionProvider, VennDocumentHighlightProvider, VennDocumentSymbolProvider, VennFormatter, VennHoverProvider, VennReferencesProvider, VennRenameProvider, VennSemanticTokenProvider, type VennServices, VennSignatureHelpProvider, buildCatalog, builtinDecos, contextAt, createImportResolver, createVennLspServices, decoNamed, decosInScope, exportedNames, findBinding, findFragment, findOccurrences, importedNames, modulePaths, occurrencesIn, parseDoc, readDoc, registerVennChecks, renderDoc, resolveFragment, startVennServer, symbolAt };
+//# sourceMappingURL=index.d.mts.map