@esportsplus/typescript 0.31.0 → 0.32.0

package/build/compiler/language-service.d.ts

@@ -1,5 +1,6 @@
 import type { SourceFile } from 'typescript/unstable/ast';
-import { type Checker, type Program } from 'typescript/unstable/sync';
+import type { FileSystem } from 'typescript/unstable/fs';
+import { API, type Checker, type Program, type Project, type Snapshot } from 'typescript/unstable/sync';
 type ScratchResult = {
     checker: Checker;
     program: Program;
@@ -9,20 +10,30 @@ type UpdateResult = {
     checker: Checker;
     program: Program;
 };
+type OpenProject = {
+    api: API;
+    dispose: () => void;
+    project: Project;
+    snapshot: Snapshot;
+};
+declare function open(configPath: string, overlay?: FileSystem): OpenProject;
 declare const dispose: (root?: string) => void;
 declare const findConfig: (startDir: string) => string | null;
-declare const invalidate: (root: string, fileName: string) => void;
+declare const invalidate: (configFileName: string, fileName: string) => void;
 declare const parse: (fileName: string, content: string) => SourceFile;
 declare const scratch: (fileName: string, content: string) => ScratchResult;
-declare const update: (root: string, fileName: string, content: string) => UpdateResult;
+declare const update: (configFileName: string, fileName: string, content: string) => UpdateResult;
+declare const updateMany: (configFileName: string, updates: Map<string, string>) => UpdateResult;
 declare const _default: {
     dispose: typeof dispose;
     findConfig: typeof findConfig;
     invalidate: typeof invalidate;
+    open: typeof open;
     parse: typeof parse;
     scratch: typeof scratch;
     update: typeof update;
+    updateMany: typeof updateMany;
 };
 export default _default;
-export { dispose, findConfig, invalidate, parse, scratch, update };
+export { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };
 export type { ScratchResult, UpdateResult };

package/build/compiler/language-service.js

@@ -31,12 +31,9 @@ function advanceScratch(id, content) {
     entry.snapshot = snapshot;
     return entry;
 }
-function createEntry(root) {
-    let configFileName = findConfig(root);
-    if (!configFileName) {
-        throw new Error(`${PACKAGE_NAME}: tsconfig.json not found`);
-    }
-    let contents = new Map(), api = new API({ cwd: root, fs: overlayFileSystem(contents) }), snapshot = api.updateSnapshot({ openProjects: [configFileName] }), project = resolveProject(snapshot, configFileName);
+function createEntry(configFileName) {
+    let root = path.dirname(configFileName);
+    let contents = new Map(), opened = open(configFileName, overlayFileSystem(contents)), { api, project, snapshot } = opened;
     for (let diagnostic of project.program.getConfigFileParsingDiagnostics()) {
         if (diagnostic.category === DiagnosticCategory.Error) {
             snapshot.dispose();
@@ -64,17 +61,39 @@ function disposeScratch(entry) {
     }
     entry.api.close();
 }
-function getEntry(root) {
-    let entry = cache.get(root);
+function getEntry(configFileName) {
+    let entry = cache.get(configFileName);
     if (!entry) {
-        entry = createEntry(root);
-        cache.set(root, entry);
+        entry = createEntry(configFileName);
+        cache.set(configFileName, entry);
     }
     return entry;
 }
 function normalize(fileName) {
     return fileName.replace(backslashes, '/');
 }
+function open(configPath, overlay) {
+    let configFileName = normalize(path.resolve(configPath)), entry = overlay === undefined ? getEntry(configFileName) : undefined, api = entry?.api ?? new API({ cwd: path.dirname(configFileName), fs: overlay }), snapshot = entry?.snapshot ?? api.updateSnapshot({ openProjects: [configFileName] }), project = entry?.project ?? resolveProject(snapshot, configFileName);
+    if (entry) {
+        return {
+            api,
+            dispose: () => dispose(configFileName),
+            project,
+            snapshot
+        };
+    }
+    return {
+        api,
+        dispose: () => {
+            if (!snapshot.isDisposed()) {
+                snapshot.dispose();
+            }
+            api.close();
+        },
+        project,
+        snapshot,
+    };
+}
 function overlayFileSystem(contents) {
     return {
         fileExists: (fileName) => {
@@ -101,7 +120,7 @@ function overlayFileSystem(contents) {
             }
             catch {
             }
-            return { directories, files: [...files, ...extra] };
+            return { directories, files: [...new Set([...files, ...extra])] };
         },
         readFile: (fileName) => {
             let content = contents.get(normalize(fileName));
@@ -192,8 +211,8 @@ const findConfig = (startDir) => {
         current = parent;
     }
 };
-const invalidate = (root, fileName) => {
-    let entry = cache.get(root);
+const invalidate = (configFileName, fileName) => {
+    let entry = cache.get(configFileName);
     if (!entry) {
         return;
     }
@@ -211,11 +230,20 @@ const scratch = (fileName, content) => {
     }
     return { checker: entry.project.checker, program: entry.project.program, sourceFile: source };
 };
-const update = (root, fileName, content) => {
-    let entry = getEntry(root), id = normalize(fileName);
-    entry.contents.set(id, content);
-    if (entry.seen.has(id)) {
-        entry.pending.add(id);
+const update = (configFileName, fileName, content) => {
+    return updateMany(configFileName, new Map([[fileName, content]]));
+};
+const updateMany = (configFileName, updates) => {
+    let entry = getEntry(configFileName), ids = [];
+    for (let [fileName, content] of updates) {
+        let id = normalize(fileName);
+        entry.contents.set(id, content);
+        ids.push(id);
+    }
+    if (ids.every(id => entry.seen.has(id))) {
+        for (let i = 0, n = ids.length; i < n; i++) {
+            entry.pending.add(ids[i]);
+        }
         let changed = [...entry.pending];
         entry.pending.clear();
         advance(entry, changed);
@@ -223,13 +251,17 @@ const update = (root, fileName, content) => {
     else {
         recreate(entry);
         entry.pending.clear();
-        entry.seen.add(id);
+        for (let i = 0, n = ids.length; i < n; i++) {
+            entry.seen.add(ids[i]);
+        }
     }
-    let source = entry.project.program.getSourceFile(id);
-    if (!source || source.text !== content) {
-        throw new Error(`${PACKAGE_NAME}: failed to load ${fileName} into the program`);
+    for (let i = 0, n = ids.length; i < n; i++) {
+        let id = ids[i], source = entry.project.program.getSourceFile(id), content = entry.contents.get(id);
+        if (!source || source.text !== content) {
+            throw new Error(`${PACKAGE_NAME}: failed to load ${id} into the program`);
+        }
     }
     return { checker: entry.project.checker, program: entry.project.program };
 };
-export default { dispose, findConfig, invalidate, parse, scratch, update };
-export { dispose, findConfig, invalidate, parse, scratch, update };
+export default { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };
+export { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };

package/build/compiler/plugins/vite.js

@@ -6,17 +6,19 @@ const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
 export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
+        let tsconfig = null;
         return {
             closeBundle() {
-                languageService.dispose(root || '');
+                languageService.dispose(tsconfig ?? '');
                 contexts.delete(root || '');
             },
             closeWatcher() {
-                languageService.dispose(root || '');
+                languageService.dispose(tsconfig ?? '');
                 contexts.delete(root || '');
             },
             configResolved(config) {
                 root ??= config.root;
+                tsconfig = languageService.findConfig(root);
             },
             enforce: 'pre',
             name: `${name}/compiler/vite`,
@@ -25,13 +27,13 @@ export default ({ name, onWatchChange, plugins }) => {
                     return null;
                 }
                 try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), { checker, program } = languageService.update(root || '', normalizedId, code), sourceFile = program.getSourceFile(normalizedId) ?? languageService.parse(normalizedId, code);
+                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), configPath = tsconfig ?? languageService.findConfig(root || ''), { checker, program } = languageService.update(configPath ?? '', normalizedId, code), sourceFile = program.getSourceFile(normalizedId) ?? languageService.parse(normalizedId, code);
                     let key = root || '', ctx = contexts.get(key);
                     if (!ctx) {
                         ctx = new Map();
                         contexts.set(key, ctx);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, { checker, program }, key, ctx);
+                    let result = coordinator.transform(plugins, code, sourceFile, { checker, configPath: configPath ?? undefined, program }, key, ctx);
                     if (!result.changed) {
                         return null;
                     }
@@ -46,7 +48,7 @@ export default ({ name, onWatchChange, plugins }) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    languageService.invalidate(root || '', id);
+                    languageService.invalidate(tsconfig ?? '', id);
                 }
             }
         };

package/build/compiler/sourcemap.d.ts

@@ -28,6 +28,7 @@ type SourceMapV3 = {
     sourcesContent?: (string | null)[];
     version: 3;
 };
+declare function resolveOffset(mapping: PositionMapping, offset: number): number;
 declare const buildGeneration: (beforeText: string, edits: Edit[]) => OffsetAnchor[];
 declare const composeEmittedMap: (map: SourceMapV3, mapping: PositionMapping, transformedText: string, originalText: string) => SourceMapV3;
 declare const decode: (mappings: string) => number[][][];
@@ -43,8 +44,9 @@ declare const _default: {
     decode: typeof decode;
     encode: typeof encode;
     originalPositionFor: typeof originalPositionFor;
+    resolveOffset: typeof resolveOffset;
     toSourceMapV3: typeof toSourceMapV3;
 };
 export default _default;
-export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };
 export type { Edit, OffsetAnchor, PositionMapping, Segment, SourceMapV3 };

package/build/compiler/sourcemap.js

@@ -115,6 +115,24 @@ function resolveOffset(mapping, offset) {
     }
     return result;
 }
+function resolveOffsets(mapping) {
+    const cursors = mapping.generations.map(() => 0);
+    return (offset) => {
+        let result = offset;
+        for (let i = mapping.generations.length - 1; i >= 0; i--) {
+            const anchors = mapping.generations[i];
+            while (cursors[i] + 1 < anchors.length &&
+                result >= anchors[cursors[i] + 1].afterStart) {
+                cursors[i] += 1;
+            }
+            const anchor = anchors[cursors[i]];
+            result = anchor.identity
+                ? anchor.beforeStart + (result - anchor.afterStart)
+                : anchor.beforeStart;
+        }
+        return result;
+    };
+}
 function segmentAt(starts, offset, genColumn) {
     let position = offsetToLineCol(starts, offset);
     return { genColumn, originalColumn: position.column, originalLine: position.line, source: 0 };
@@ -223,16 +241,16 @@ const originalPositionFor = (mapping, transformedText, originalText, line, colum
     return offsetToLineCol(lineStarts(originalText), resolveOffset(mapping, base + column));
 };
 const toSourceMapV3 = (mapping, transformedText, originalText, source) => {
-    let oStarts = lineStarts(originalText), segments = [], tStarts = lineStarts(transformedText);
+    let oStarts = lineStarts(originalText), resolve = resolveOffsets(mapping), segments = [], tStarts = lineStarts(transformedText);
     for (let line = 0, n = tStarts.length; line < n; line++) {
-        let end = line + 1 < n ? tStarts[line + 1] - 1 : transformedText.length, previous = resolveOffset(mapping, tStarts[line]), start = tStarts[line];
+        let end = line + 1 < n ? tStarts[line + 1] - 1 : transformedText.length, previous = resolve(tStarts[line]), start = tStarts[line];
         let row = [segmentAt(oStarts, previous, 0)];
         for (let offset = start + 1; offset < end; offset++) {
             let current = charClass(transformedText.charCodeAt(offset));
             if (current !== CLASS_OTHER && current === charClass(transformedText.charCodeAt(offset - 1))) {
                 continue;
             }
-            let resolved = resolveOffset(mapping, offset);
+            let resolved = resolve(offset);
             if (resolved === previous) {
                 continue;
             }
@@ -243,5 +261,5 @@ const toSourceMapV3 = (mapping, transformedText, originalText, source) => {
     }
     return { mappings: encode(segmentsToRaw(segments)), names: [], sources: [source], version: 3 };
 };
-export default { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };
-export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };
+export default { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };

package/build/jsonc.d.ts

@@ -0,0 +1,2 @@
+declare const stripJsonc: (text: string) => string;
+export { stripJsonc };

package/build/jsonc.js

@@ -0,0 +1,85 @@
+const stripJsonc = (text) => {
+    let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
+    for (let i = 0, n = text.length; i < n; i++) {
+        let char = text[i], next = text[i + 1];
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                stripped += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            stripped += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            stripped += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        stripped += char;
+    }
+    escaped = false;
+    inString = false;
+    let result = '';
+    for (let i = 0, n = stripped.length; i < n; i++) {
+        let char = stripped[i];
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === ',') {
+            let j = i + 1;
+            while (j < n && /\s/.test(stripped[j])) {
+                j++;
+            }
+            if (stripped[j] === ']' || stripped[j] === '}') {
+                continue;
+            }
+        }
+        result += char;
+    }
+    return result;
+};
+export { stripJsonc };

package/build/lsp/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lsp/bin.js

@@ -0,0 +1,2 @@
+import { startServer } from './server.js';
+startServer();

package/build/lsp/diagnostics.d.ts

@@ -0,0 +1,10 @@
+import { DiagnosticSeverity } from 'vscode-languageserver/node';
+import type { CodeAction, Diagnostic as LspDiagnostic, Hover } from 'vscode-languageserver/node';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Diagnostic as AnalyzeDiagnostic } from '../probe/kernel/types.js';
+export type DocumentResolver = (fileName: string) => TextDocument | undefined;
+declare function toLspDiagnostic(diagnostic: AnalyzeDiagnostic, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): LspDiagnostic;
+declare function groupByFile(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): Map<string, LspDiagnostic[]>;
+declare function hoverAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, offset: number, document: TextDocument): Hover | undefined;
+declare function codeActionsAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, startOffset: number, endOffset: number, document: TextDocument, uriOf: (fileName: string) => string): CodeAction[];
+export { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt, toLspDiagnostic };

package/build/lsp/diagnostics.js

@@ -0,0 +1,69 @@
+import { CodeActionKind, DiagnosticSeverity, MarkupKind } from 'vscode-languageserver/node';
+function rangeOf(location, document) {
+    if (document) {
+        return { start: document.positionAt(location.pos), end: document.positionAt(location.end) };
+    }
+    let start = { line: Math.max(0, location.line - 1), character: Math.max(0, location.column - 1) };
+    return { start, end: { line: start.line, character: start.character + 1 } };
+}
+function relatedOf(diagnostic, resolve, uriOf) {
+    return diagnostic.related.map((related) => ({
+        location: { range: rangeOf(related.location, resolve(related.location.fileName)), uri: uriOf(related.location.fileName) },
+        message: related.message,
+    }));
+}
+function toLspDiagnostic(diagnostic, severity, resolve, uriOf) {
+    return {
+        code: diagnostic.channel,
+        message: diagnostic.message,
+        range: rangeOf(diagnostic.location, resolve(diagnostic.location.fileName)),
+        relatedInformation: relatedOf(diagnostic, resolve, uriOf),
+        severity,
+        source: 'analyze',
+    };
+}
+function groupByFile(diagnostics, severity, resolve, uriOf) {
+    let grouped = new Map();
+    for (let i = 0, n = diagnostics.length; i < n; i++) {
+        let diagnostic = diagnostics[i], fileName = diagnostic.location.fileName, list = grouped.get(fileName);
+        if (!list) {
+            list = [];
+            grouped.set(fileName, list);
+        }
+        list.push(toLspDiagnostic(diagnostic, severity, resolve, uriOf));
+    }
+    return grouped;
+}
+function hoverAt(diagnostics, offset, document) {
+    let hits = diagnostics.filter((diagnostic) => offset >= diagnostic.location.pos && offset <= diagnostic.location.end);
+    if (hits.length === 0) {
+        return undefined;
+    }
+    let lines = [];
+    for (let i = 0, n = hits.length; i < n; i++) {
+        let diagnostic = hits[i];
+        lines.push(`**${diagnostic.channel}** — ${diagnostic.message}`);
+        for (let related of diagnostic.related) {
+            lines.push(`- ${related.message}`);
+        }
+    }
+    return { contents: { kind: MarkupKind.Markdown, value: lines.join('\n\n') }, range: rangeOf(hits[0].location, document) };
+}
+function codeActionsAt(diagnostics, startOffset, endOffset, document, uriOf) {
+    let actions = [];
+    for (let diagnostic of diagnostics) {
+        if (diagnostic.location.end < startOffset || diagnostic.location.pos > endOffset) {
+            continue;
+        }
+        for (let fix of diagnostic.fixes ?? []) {
+            let changes = {};
+            for (let edit of fix.edits) {
+                let uri = uriOf(edit.fileName), range = { start: document.positionAt(edit.pos), end: document.positionAt(edit.end) };
+                (changes[uri] ??= []).push({ newText: edit.newText, range });
+            }
+            actions.push({ edit: { changes }, kind: CodeActionKind.QuickFix, title: fix.title });
+        }
+    }
+    return actions;
+}
+export { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt, toLspDiagnostic };

package/build/lsp/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer, startServer } from './server.js';
+export { AnalyzeWorkspace } from './workspace.js';

package/build/lsp/index.js

@@ -0,0 +1,2 @@
+export { createServer, startServer } from './server.js';
+export { AnalyzeWorkspace } from './workspace.js';

package/build/lsp/server.d.ts

@@ -0,0 +1,4 @@
+import type { Connection } from 'vscode-languageserver/node';
+declare function createServer(connection: Connection): void;
+declare function startServer(): void;
+export { createServer, startServer };

package/build/lsp/server.js

@@ -0,0 +1,130 @@
+import * as NodeFS from 'node:fs';
+import * as NodePath from 'node:path';
+import { CodeActionKind, createConnection, ProposedFeatures, StreamMessageReader, StreamMessageWriter, TextDocuments, TextDocumentSyncKind } from 'vscode-languageserver/node';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt } from './diagnostics.js';
+import { AnalyzeWorkspace } from './workspace.js';
+function pathKey(fileName) {
+    let resolved = NodePath.resolve(fileName);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function findTsconfig(rootDir) {
+    let candidate = NodePath.join(rootDir, 'tsconfig.json');
+    return NodeFS.existsSync(candidate) ? candidate : undefined;
+}
+function rootFromInitialize(params) {
+    let folder = params.workspaceFolders?.[0]?.uri ?? params.rootUri ?? undefined;
+    return folder ? fileURLToPath(folder) : undefined;
+}
+function createServer(connection) {
+    let analyzed = new Map(), documents = new TextDocuments(TextDocument), pending = new Set(), published = new Set(), timer, workspace;
+    function runAnalysis() {
+        timer = undefined;
+        if (!workspace || !workspace.config) {
+            return;
+        }
+        let changed = [...pending];
+        pending.clear();
+        try {
+            workspace.refresh(changed);
+        }
+        catch (error) {
+            connection.console.error(`analyze: snapshot refresh failed — ${error.message}`);
+            return;
+        }
+        let result = workspace.analyze();
+        if (!result) {
+            return;
+        }
+        analyzed = new Map();
+        for (let diagnostic of result.diagnostics) {
+            let key = pathKey(diagnostic.location.fileName), list = analyzed.get(key);
+            if (!list) {
+                list = [];
+                analyzed.set(key, list);
+            }
+            list.push(diagnostic);
+        }
+        let openByPath = new Map(documents.all().map((document) => [pathKey(fileURLToPath(document.uri)), document])), resolve = (fileName) => openByPath.get(pathKey(fileName)), severity = workspace.config.severity === 'warning' ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error, uriOf = (fileName) => openByPath.get(pathKey(fileName))?.uri ?? pathToFileURL(fileName).toString(), grouped = groupByFile(result.diagnostics, severity, resolve, uriOf), next = new Set();
+        for (let [fileName, diagnostics] of grouped) {
+            let uri = uriOf(fileName);
+            next.add(uri);
+            connection.sendDiagnostics({ diagnostics, uri });
+        }
+        for (let uri of published) {
+            if (!next.has(uri)) {
+                connection.sendDiagnostics({ diagnostics: [], uri });
+            }
+        }
+        published = next;
+    }
+    function schedule(changed) {
+        for (let i = 0, n = changed.length; i < n; i++) {
+            pending.add(changed[i]);
+        }
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(runAnalysis, 300);
+    }
+    connection.onInitialize((params) => {
+        let root = rootFromInitialize(params);
+        if (root) {
+            let tsconfig = findTsconfig(root);
+            if (tsconfig) {
+                workspace = new AnalyzeWorkspace(tsconfig);
+            }
+        }
+        return {
+            capabilities: {
+                codeActionProvider: { codeActionKinds: [CodeActionKind.QuickFix] },
+                hoverProvider: true,
+                textDocumentSync: TextDocumentSyncKind.Incremental,
+            },
+        };
+    });
+    connection.onInitialized(() => {
+        if (workspace) {
+            schedule([]);
+        }
+    });
+    connection.onShutdown(() => {
+        workspace?.dispose();
+        workspace = undefined;
+    });
+    connection.onHover((params) => {
+        let document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        let diagnostics = analyzed.get(pathKey(fileURLToPath(params.textDocument.uri)));
+        return diagnostics ? hoverAt(diagnostics, document.offsetAt(params.position), document) ?? null : null;
+    });
+    connection.onCodeAction((params) => {
+        let document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return [];
+        }
+        let target = pathKey(fileURLToPath(params.textDocument.uri)), diagnostics = analyzed.get(target);
+        if (!diagnostics) {
+            return [];
+        }
+        let uriOf = (fileName) => (pathKey(fileName) === target ? params.textDocument.uri : pathToFileURL(fileName).toString());
+        return codeActionsAt(diagnostics, document.offsetAt(params.range.start), document.offsetAt(params.range.end), document, uriOf);
+    });
+    documents.onDidOpen((event) => schedule([fileURLToPath(event.document.uri)]));
+    documents.onDidSave((event) => {
+        let fileName = fileURLToPath(event.document.uri);
+        if (workspace && NodePath.basename(fileName) === 'tsconfig.json') {
+            workspace.reloadConfig();
+        }
+        schedule([fileName]);
+    });
+    documents.listen(connection);
+    connection.listen();
+}
+function startServer() {
+    createServer(createConnection(ProposedFeatures.all, new StreamMessageReader(process.stdin), new StreamMessageWriter(process.stdout)));
+}
+export { createServer, startServer };

package/build/lsp/workspace.d.ts

@@ -0,0 +1,14 @@
+import type { AnalyzeResult } from '../probe/kernel/analyze.js';
+import type { AnalyzeConfig } from '../probe/kernel/types.js';
+declare class AnalyzeWorkspace {
+    private api;
+    private configPath;
+    private snapshot;
+    config: AnalyzeConfig | undefined;
+    constructor(tsconfigPath: string);
+    reloadConfig(): void;
+    refresh(changed: ReadonlyArray<string>): void;
+    analyze(): AnalyzeResult | undefined;
+    dispose(): void;
+}
+export { AnalyzeWorkspace };