@nvl/sveltex-language-server 0.2.0

package/dist/core/mapper.js

@@ -0,0 +1,223 @@
+// File description: `SourceMap` — a bidirectional, offset-based mapper between
+// the source `.sveltex` document and the generated virtual `.svelte` document.
+//
+// Geometry is expressed with `Mapping` offset-triples (see `mapping.ts`). LSP
+// requests, however, speak in line/character `Position`s, so the mapper also
+// holds a `TextDocument` view of each side purely to convert offsets <-> LSP
+// positions. The two concerns are kept separate: all mapping math is done on
+// integer offsets, and line/character conversion is a thin shell on top.
+import { TextDocument, } from 'vscode-languageserver-textdocument';
+/**
+ * Bidirectional mapper between a source document and its generated counterpart.
+ *
+ * Construct one per open `.sveltex` file (rebuilt on every debounced re-parse).
+ * The mappings must be sorted by `sourceOffset`; {@link SourceMap.create}
+ * enforces this so callers need not.
+ */
+export class SourceMap {
+    /** Mappings sorted ascending by `sourceOffset`. */
+    #bySource;
+    /** The same mappings sorted ascending by `generatedOffset`. */
+    #byGenerated;
+    /** Text-document view of the source `.sveltex` file. */
+    #sourceDoc;
+    /** Text-document view of the generated virtual `.svelte` file. */
+    #generatedDoc;
+    constructor(mappings, sourceText, generatedText) {
+        this.#bySource = [...mappings].sort((a, b) => a.sourceOffset - b.sourceOffset);
+        this.#byGenerated = [...mappings].sort((a, b) => a.generatedOffset - b.generatedOffset);
+        // The language id is irrelevant; these documents are used only for
+        // offset <-> position arithmetic.
+        this.#sourceDoc = TextDocument.create('mem://source', 'sveltex', 0, sourceText);
+        this.#generatedDoc = TextDocument.create('mem://generated', 'svelte', 0, generatedText);
+    }
+    /**
+     * Builds a {@link SourceMap}.
+     *
+     * @param mappings - The span pairs linking the two documents. Order does
+     * not matter; they are sorted internally.
+     * @param sourceText - Full text of the source `.sveltex` document.
+     * @param generatedText - Full text of the generated `.svelte` document.
+     */
+    static create(mappings, sourceText, generatedText) {
+        return new SourceMap(mappings, sourceText, generatedText);
+    }
+    /** The generated virtual document's full text. */
+    get generatedText() {
+        return this.#generatedDoc.getText();
+    }
+    /** The source document's full text. */
+    get sourceText() {
+        return this.#sourceDoc.getText();
+    }
+    // ----- offset translation ------------------------------------------------
+    /**
+     * Translates a source-document offset to a generated-document offset.
+     *
+     * @param sourceOffset - Offset in the `.sveltex` document.
+     * @returns The corresponding generated offset, or `undefined` if the offset
+     * falls outside every mapped span (i.e. inside a non-delegated region).
+     */
+    sourceOffsetToGenerated(sourceOffset) {
+        const m = findContaining(this.#bySource, sourceOffset, (x) => x.sourceOffset, (x) => x.sourceLength);
+        if (!m)
+            return undefined;
+        return translate(sourceOffset, m.sourceOffset, m.sourceLength, m.generatedOffset, m.generatedLength);
+    }
+    /**
+     * Translates a generated-document offset to a source-document offset.
+     *
+     * @param generatedOffset - Offset in the virtual `.svelte` document.
+     * @returns The corresponding source offset, or `undefined` if the offset
+     * falls outside every mapped span.
+     */
+    generatedOffsetToSource(generatedOffset) {
+        const m = findContaining(this.#byGenerated, generatedOffset, (x) => x.generatedOffset, (x) => x.generatedLength);
+        if (!m)
+            return undefined;
+        return translate(generatedOffset, m.generatedOffset, m.generatedLength, m.sourceOffset, m.sourceLength);
+    }
+    // ----- position translation ---------------------------------------------
+    /**
+     * Translates a source-document {@link Position} to a generated-document
+     * position.
+     *
+     * @returns The mapped position, or `undefined` if it lies in an unmapped
+     * region.
+     */
+    sourcePositionToGenerated(position) {
+        const offset = this.#sourceDoc.offsetAt(position);
+        const generated = this.sourceOffsetToGenerated(offset);
+        if (generated === undefined)
+            return undefined;
+        return this.#generatedDoc.positionAt(generated);
+    }
+    /**
+     * Translates a generated-document {@link Position} to a source-document
+     * position.
+     *
+     * @returns The mapped position, or `undefined` if it lies in an unmapped
+     * region.
+     */
+    generatedPositionToSource(position) {
+        const offset = this.#generatedDoc.offsetAt(position);
+        const source = this.generatedOffsetToSource(offset);
+        if (source === undefined)
+            return undefined;
+        return this.#sourceDoc.positionAt(source);
+    }
+    // ----- range translation -------------------------------------------------
+    /**
+     * Translates a source-document {@link Range} to a generated-document range.
+     *
+     * @returns The mapped range, or `undefined` if either endpoint is unmapped.
+     *
+     * @remarks
+     * A range is only translated when _both_ endpoints land in mapped spans.
+     * This is the conservative choice: a half-mapped range would produce a
+     * nonsensical generated range and confuse the embedded server.
+     */
+    sourceRangeToGenerated(range) {
+        const start = this.sourcePositionToGenerated(range.start);
+        const end = this.sourcePositionToGenerated(range.end);
+        if (!start || !end)
+            return undefined;
+        return { start, end };
+    }
+    /**
+     * Translates a generated-document {@link Range} to a source-document range.
+     *
+     * @returns The mapped range, or `undefined` if either endpoint is unmapped.
+     */
+    generatedRangeToSource(range) {
+        const start = this.generatedPositionToSource(range.start);
+        const end = this.generatedPositionToSource(range.end);
+        if (!start || !end)
+            return undefined;
+        return { start, end };
+    }
+    // ----- feature flags -----------------------------------------------------
+    /**
+     * Returns the {@link MappingFeatures} governing a given offset.
+     *
+     * @param offset - The offset to query.
+     * @param direction - `'toGenerated'` to interpret `offset` as a source
+     * offset, `'toSource'` to interpret it as a generated offset.
+     * @returns The feature flags, or `undefined` if the offset is unmapped.
+     */
+    featuresAt(offset, direction) {
+        const m = direction === 'toGenerated'
+            ? findContaining(this.#bySource, offset, (x) => x.sourceOffset, (x) => x.sourceLength)
+            : findContaining(this.#byGenerated, offset, (x) => x.generatedOffset, (x) => x.generatedLength);
+        return m?.features;
+    }
+}
+/**
+ * Maps a position within `[fromOffset, fromOffset + fromLength]` onto the
+ * corresponding position within `[toOffset, toOffset + toLength]`.
+ *
+ * For the v1 identity case (`fromLength === toLength`) this is simply
+ * `toOffset + (offset - fromOffset)`. When the spans differ in length the
+ * offset is clamped to the destination span — a defensive measure for future
+ * non-affine mappings; it never triggers in v1.
+ */
+function translate(offset, fromOffset, fromLength, toOffset, toLength) {
+    const delta = offset - fromOffset;
+    if (delta <= 0)
+        return toOffset;
+    if (delta >= fromLength)
+        return toOffset + toLength;
+    if (fromLength === toLength)
+        return toOffset + delta;
+    return toOffset + Math.min(delta, toLength);
+}
+/**
+ * Binary-searches a list of mappings (sorted by the offset accessor) for the
+ * mapping whose span contains `offset`.
+ *
+ * The span is treated as the half-open interval `[start, start + length)`, with
+ * one exception: a zero-length probe at `start + length` (the very end of a
+ * span) also matches, so that a caret positioned immediately after the last
+ * character of a mapped region still maps. This matches how editors place the
+ * cursor at end-of-token.
+ *
+ * @param sorted - Mappings sorted ascending by `getStart`.
+ * @param offset - The offset to locate.
+ * @param getStart - Accessor for a mapping's span start.
+ * @param getLength - Accessor for a mapping's span length.
+ * @returns The containing mapping, or `undefined`.
+ */
+function findContaining(sorted, offset, getStart, getLength) {
+    let lo = 0;
+    let hi = sorted.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const m = sorted[mid];
+        if (!m)
+            break;
+        const start = getStart(m);
+        const end = start + getLength(m);
+        if (offset < start) {
+            hi = mid - 1;
+        }
+        else if (offset > end) {
+            lo = mid + 1;
+        }
+        else if (offset === end && offset !== start) {
+            // `offset` is exactly at this span's end. Prefer the next span if
+            // it starts here (so an interior boundary maps into the right-hand
+            // region); otherwise accept this span (true end of document).
+            const next = sorted[mid + 1];
+            if (next && getStart(next) === offset) {
+                lo = mid + 1;
+            }
+            else {
+                return m;
+            }
+        }
+        else {
+            return m;
+        }
+    }
+    return undefined;
+}

package/dist/core/mapping.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Per-mapping feature flags, mirroring Volar's `CodeInformation`.
+ *
+ * Every flag defaults to `true` when the mapping is created via
+ * {@link identityMapping}. They exist so that later phases can, for example,
+ * keep a region navigable (go-to-definition) while suppressing diagnostics in
+ * it, without changing the mapping geometry.
+ */
+export interface MappingFeatures {
+    /** Whether diagnostics inside this mapping should surface to the user. */
+    diagnostics: boolean;
+    /** Whether hover / signature-help requests are answered here. */
+    verification: boolean;
+    /** Whether completion is offered here. */
+    completion: boolean;
+    /** Whether semantic-token / highlight requests are answered here. */
+    semantic: boolean;
+    /** Whether go-to-definition / references / rename are answered here. */
+    navigation: boolean;
+}
+/**
+ * Links one contiguous span of the source document to one contiguous span of
+ * the generated document.
+ *
+ * Unlike Volar's `CodeMapping` (which packs several spans into parallel
+ * arrays), each `Mapping` here describes exactly one span pair. The arrays live
+ * one level up, in the {@link SourceMap}. Keeping one span per object makes the
+ * binary searches in {@link SourceMap} trivial to reason about and test.
+ *
+ * @remarks
+ * In v1 every delegated region is copied byte-for-byte, so `sourceLength` and
+ * `generatedLength` are always equal and the mapping is affine with slope 1.
+ * The fields are kept independent regardless, so that a future phase which
+ * expands Markdown to HTML (changing lengths) needs no API change here.
+ */
+export interface Mapping {
+    /** Offset of the span in the source `.sveltex` document. */
+    sourceOffset: number;
+    /** Length of the span in the source document. */
+    sourceLength: number;
+    /** Offset of the span in the generated `.svelte` document. */
+    generatedOffset: number;
+    /** Length of the span in the generated document. */
+    generatedLength: number;
+    /** Feature flags for content inside this span. */
+    features: MappingFeatures;
+}
+/** Returns a {@link MappingFeatures} object with every feature enabled. */
+export declare function allFeatures(): MappingFeatures;
+/**
+ * Builds an identity {@link Mapping}: a span that occupies the same length in
+ * both documents (the v1 case for every delegated region).
+ *
+ * @param sourceOffset - Start of the span in the source document.
+ * @param generatedOffset - Start of the span in the generated document.
+ * @param length - Length of the span (identical in both documents).
+ * @param features - Feature flags; defaults to all-enabled.
+ */
+export declare function identityMapping(sourceOffset: number, generatedOffset: number, length: number, features?: MappingFeatures): Mapping;

package/dist/core/mapping.js

@@ -0,0 +1,37 @@
+// File description: The `Mapping` data model — a single offset-triple linking a
+// span of the source `.sveltex` document to a span of the generated virtual
+// `.svelte` document.
+//
+// This is a deliberate, trimmed-down adaptation of Volar's `CodeMapping`
+// representation (`sourceOffsets[]` / `generatedOffsets[]` / `lengths[]` plus
+// per-region `CodeInformation` feature flags). We do NOT depend on Volar — the
+// architecture brief is explicit that Volar cannot host the real
+// `svelte-language-server` — we only borrow its proven data shape.
+/** Returns a {@link MappingFeatures} object with every feature enabled. */
+export function allFeatures() {
+    return {
+        diagnostics: true,
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    };
+}
+/**
+ * Builds an identity {@link Mapping}: a span that occupies the same length in
+ * both documents (the v1 case for every delegated region).
+ *
+ * @param sourceOffset - Start of the span in the source document.
+ * @param generatedOffset - Start of the span in the generated document.
+ * @param length - Length of the span (identical in both documents).
+ * @param features - Feature flags; defaults to all-enabled.
+ */
+export function identityMapping(sourceOffset, generatedOffset, length, features = allFeatures()) {
+    return {
+        sourceOffset,
+        sourceLength: length,
+        generatedOffset,
+        generatedLength: length,
+        features,
+    };
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1,34 @@
+import { type DocumentSymbol, type FoldingRange, type Position, type SelectionRange } from 'vscode-languageserver-protocol';
+import type { SveltexConfigSnapshot } from './config.js';
+/**
+ * Computes document symbols for a `.sveltex` file: a nested outline built from
+ * its Markdown headings.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns A hierarchical list of {@link DocumentSymbol}s. Headings nest by
+ * level (an `##` becomes a child of the preceding `#`).
+ */
+export declare function computeDocumentSymbols(document: string, config: SveltexConfigSnapshot): DocumentSymbol[];
+/**
+ * Computes folding ranges for a `.sveltex` file.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns Folding ranges for multi-line block constructs: headings (folding
+ * down to the next same-or-higher heading), fenced code blocks, lists and
+ * blockquotes.
+ */
+export declare function computeFoldingRanges(document: string, config: SveltexConfigSnapshot): FoldingRange[];
+/**
+ * Computes selection ranges for a `.sveltex` file: for each requested
+ * {@link Position}, the chain of progressively larger mdast nodes that contain
+ * it.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param positions - The caret positions to expand.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns One {@link SelectionRange} per input position (index-aligned). A
+ * position with no enclosing node yields a degenerate empty range.
+ */
+export declare function computeSelectionRanges(document: string, positions: Position[], config: SveltexConfigSnapshot): SelectionRange[];

package/dist/core/markdown.js

@@ -0,0 +1,215 @@
+// File description: Native Markdown language features derived from the mdast.
+//
+// The embedded Svelte language server understands the HTML subset of a
+// `.sveltex` file but nothing of its Markdown structure. This module fills that
+// gap by parsing the document with SvelTeX's own `parseToMdast` and walking the
+// resulting tree to produce document symbols, folding ranges and selection
+// ranges. These features need no position mapping: the mdast carries offsets on
+// the original `.sveltex` source directly.
+import { FoldingRangeKind, SymbolKind, } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { parseToMdast } from '@nvl/sveltex/dist/utils/escape.js';
+/**
+ * Parses a `.sveltex` document into an mdast root.
+ *
+ * @returns The mdast root, or `undefined` if parsing throws.
+ */
+function parse(document, config) {
+    try {
+        return parseToMdast(document, [...config.verbatimTags, 'script', 'style'], config.mathDelims, config.directives);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Depth-first pre-order walk over an mdast tree. */
+function walk(node, visit) {
+    visit(node);
+    for (const child of node.children ?? []) {
+        walk(child, visit);
+    }
+}
+/** Extracts the concatenated plain text of a node's literal descendants. */
+function textOf(node) {
+    let text = '';
+    walk(node, (n) => {
+        if (typeof n.value === 'string')
+            text += n.value;
+    });
+    return text.trim();
+}
+/**
+ * Computes document symbols for a `.sveltex` file: a nested outline built from
+ * its Markdown headings.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns A hierarchical list of {@link DocumentSymbol}s. Headings nest by
+ * level (an `##` becomes a child of the preceding `#`).
+ */
+export function computeDocumentSymbols(document, config) {
+    const root = parse(document, config);
+    if (!root)
+        return [];
+    const doc = TextDocument.create('mem://md', 'sveltex', 0, document);
+    const roots = [];
+    const stack = [];
+    walk(root, (node) => {
+        if (node.type !== 'heading' || !node.position)
+            return;
+        const depth = node.depth ?? 1;
+        const range = {
+            start: doc.positionAt(node.position.start.offset),
+            end: doc.positionAt(node.position.end.offset),
+        };
+        const symbol = {
+            name: textOf(node) || `H${String(depth)}`,
+            kind: SymbolKind.String,
+            range,
+            selectionRange: range,
+            children: [],
+        };
+        // Pop headings of equal or deeper level; the remaining top of stack,
+        // if any, is this heading's parent.
+        while (stack.length > 0) {
+            const top = stack[stack.length - 1];
+            if (top && top.depth >= depth) {
+                stack.pop();
+            }
+            else {
+                break;
+            }
+        }
+        const parent = stack[stack.length - 1];
+        if (parent) {
+            parent.symbol.children?.push(symbol);
+        }
+        else {
+            roots.push(symbol);
+        }
+        stack.push({ depth, symbol });
+    });
+    return roots;
+}
+/**
+ * Computes folding ranges for a `.sveltex` file.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns Folding ranges for multi-line block constructs: headings (folding
+ * down to the next same-or-higher heading), fenced code blocks, lists and
+ * blockquotes.
+ */
+export function computeFoldingRanges(document, config) {
+    const root = parse(document, config);
+    if (!root)
+        return [];
+    const doc = TextDocument.create('mem://md', 'sveltex', 0, document);
+    const ranges = [];
+    /** Adds a folding range spanning `[startOffset, endOffset)` if multi-line. */
+    const add = (startOffset, endOffset, kind) => {
+        const startLine = doc.positionAt(startOffset).line;
+        const endLine = doc.positionAt(endOffset).line;
+        if (endLine > startLine) {
+            ranges.push(kind === undefined
+                ? { startLine, endLine }
+                : { startLine, endLine, kind });
+        }
+    };
+    // Block-level constructs fold as a whole.
+    walk(root, (node) => {
+        if (!node.position)
+            return;
+        switch (node.type) {
+            case 'code':
+                add(node.position.start.offset, node.position.end.offset, FoldingRangeKind.Region);
+                break;
+            case 'list':
+            case 'blockquote':
+            case 'table':
+                add(node.position.start.offset, node.position.end.offset);
+                break;
+            default:
+                break;
+        }
+    });
+    const headings = [];
+    walk(root, (node) => {
+        if (node.type === 'heading' && node.position) {
+            headings.push({
+                depth: node.depth ?? 1,
+                startOffset: node.position.start.offset,
+            });
+        }
+    });
+    for (let i = 0; i < headings.length; i++) {
+        const current = headings[i];
+        if (!current)
+            continue;
+        let endOffset = document.length;
+        for (let j = i + 1; j < headings.length; j++) {
+            const next = headings[j];
+            if (next && next.depth <= current.depth) {
+                endOffset = next.startOffset;
+                break;
+            }
+        }
+        // End the fold at the end of the previous line, not the next heading.
+        const endLine = Math.max(doc.positionAt(current.startOffset).line, doc.positionAt(endOffset).line - 1);
+        const startLine = doc.positionAt(current.startOffset).line;
+        if (endLine > startLine) {
+            ranges.push({ startLine, endLine });
+        }
+    }
+    return ranges;
+}
+/**
+ * Computes selection ranges for a `.sveltex` file: for each requested
+ * {@link Position}, the chain of progressively larger mdast nodes that contain
+ * it.
+ *
+ * @param document - Full text of the `.sveltex` document.
+ * @param positions - The caret positions to expand.
+ * @param config - Resolved SvelTeX config snapshot.
+ * @returns One {@link SelectionRange} per input position (index-aligned). A
+ * position with no enclosing node yields a degenerate empty range.
+ */
+export function computeSelectionRanges(document, positions, config) {
+    const root = parse(document, config);
+    const doc = TextDocument.create('mem://md', 'sveltex', 0, document);
+    return positions.map((position) => {
+        const offset = doc.offsetAt(position);
+        // Collect every node whose span contains `offset`, smallest last.
+        const containing = [];
+        if (root) {
+            walk(root, (node) => {
+                if (!node.position)
+                    return;
+                const start = node.position.start.offset;
+                const end = node.position.end.offset;
+                if (offset >= start && offset <= end) {
+                    containing.push(node);
+                }
+            });
+        }
+        containing.sort((a, b) => {
+            const aLen = (a.position?.end.offset ?? 0) - (a.position?.start.offset ?? 0);
+            const bLen = (b.position?.end.offset ?? 0) - (b.position?.start.offset ?? 0);
+            return bLen - aLen; // widest first
+        });
+        // Build the nested chain from widest to narrowest.
+        let selectionRange;
+        for (const node of containing) {
+            if (!node.position)
+                continue;
+            const range = {
+                start: doc.positionAt(node.position.start.offset),
+                end: doc.positionAt(node.position.end.offset),
+            };
+            selectionRange = selectionRange
+                ? { range, parent: selectionRange }
+                : { range };
+        }
+        return selectionRange ?? { range: { start: position, end: position } };
+    });
+}

package/dist/core/region-forwarding.d.ts

@@ -0,0 +1,90 @@
+import { type CompletionItem, type CompletionList, type Hover, type Position } from 'vscode-languageserver-protocol';
+import type { Region } from './regions.js';
+import type { SveltexConfigSnapshot } from './config.js';
+/**
+ * Whether `region` carries a LaTeX/TeX environment, i.e. its opening tag is one
+ * of the configured `latexTags` (case-insensitive, as SvelTeX tags are).
+ *
+ * @param source - Full text of the `.sveltex` document.
+ * @param region - The region to test (only `verbatim` regions can match).
+ * @param latexTags - The configured LaTeX verbatim tags.
+ */
+export declare function isLatexVerbatimRegion(source: string, region: Region, latexTags: readonly string[]): boolean;
+/**
+ * A sink for human-readable, operational log lines about the lifecycle of the
+ * child language servers (TexLab and the math language server).
+ *
+ * Spawning a child is best-effort and was previously silent: if `texlab` was
+ * not on `PATH`, or a child crashed on start, forwarding simply returned
+ * nothing with no trace. The host wires this sink to the editor's output
+ * channel so those outcomes are visible and diagnosable.
+ */
+export type ForwarderLog = (message: string) => void;
+/**
+ * Relabels `Text`-kind completion items as `Function`.
+ *
+ * TexLab tags every command completion `CompletionItemKind.Text` — the generic
+ * "a word that occurs in the document" kind. VS Code routes `Text` items
+ * through the `editor.suggest.showWords` toggle and folds them in with
+ * buffer-word suggestions, so a user who has turned word suggestions off (a
+ * common preference) sees *no* `<tex>` completions at all. A LaTeX control
+ * sequence is a function-like macro, not a stray word, so it is presented as
+ * `Function`: both more accurate and immune to the `showWords` toggle.
+ *
+ * @param result - A completion result already remapped to `.sveltex` coords.
+ * @returns The same result with every `Text`-kind item relabelled `Function`.
+ */
+export declare function withFunctionCompletionKind(result: CompletionItem[] | CompletionList | null): CompletionItem[] | CompletionList | null;
+/**
+ * Manages the child language servers that back non-delegated regions of one
+ * SvelTeX workspace, and forwards hover/completion requests to them.
+ *
+ * One instance is created per `createServer` call. The children are spawned
+ * lazily on first use and reused for the lifetime of the server.
+ */
+export declare class RegionForwarder {
+    #private;
+    /**
+     * @param config - The resolved SvelTeX config snapshot. Replaceable via
+     * {@link updateConfig} when the workspace config is (re)loaded.
+     * @param log - Optional sink for child-server lifecycle log lines (TexLab /
+     * the math server found, started, or failed). Defaults to discarding them.
+     */
+    constructor(config: SveltexConfigSnapshot, log?: ForwarderLog);
+    /** Replaces the config snapshot (e.g. after the config file is loaded). */
+    updateConfig(config: SveltexConfigSnapshot): void;
+    /**
+     * Overrides the location of the math language server child.
+     *
+     * Standalone use needs no override — the server is resolved from
+     * `node_modules`. A host that has bundled the server to a sibling file (the
+     * VS Code extension) calls this with that file's absolute path before any
+     * math region is forwarded, since `node_modules` will not exist at runtime.
+     *
+     * @param serverPath - Absolute path of the math server's `bin/server.js`,
+     * or `undefined` to keep resolving from `node_modules`.
+     */
+    setMathServerPath(serverPath: string | undefined): void;
+    /**
+     * Forwards a hover request that lands in `region` to the appropriate child
+     * server.
+     *
+     * @param source - Full text of the `.sveltex` document.
+     * @param sourceUri - The `.sveltex` document URI.
+     * @param region - The region the request position falls in.
+     * @param position - The request position, in `.sveltex` coordinates.
+     * @returns The hover, mapped back to `.sveltex` coordinates, or `null` if
+     * the region is not forwardable or the child has nothing to offer.
+     */
+    forwardHover(source: string, sourceUri: string, region: Region, position: Position): Promise<Hover | null>;
+    /**
+     * Forwards a completion request that lands in `region` to the appropriate
+     * child server.
+     *
+     * @returns The completion result, mapped back to `.sveltex` coordinates,
+     * or `null` if the region is not forwardable.
+     */
+    forwardCompletion(source: string, sourceUri: string, region: Region, position: Position): Promise<CompletionItem[] | CompletionList | null>;
+    /** Shuts every spawned child server down. */
+    stop(): Promise<void>;
+}