@akira-tl/forgerelay 0.4.4 → 0.4.6

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.4.6] - 2026-08-11
+
+### Added
+
+- Added published `npm run lsp:interop` acceptance for `typescript-language-server`, Pyright, `rust-analyzer`, `gopls`, and `clangd`: detected executables run through built-in discovery and real stdio LSP, while missing external servers are reported as explicit skips without automatic installation.
+- Extended the real 7677 HTTP/OAuth/MCP acceptance path to execute all six `code.intelligence` v1 operations, normalized results, a stable error path, and Language-service `shutdown -> exit` behavior while keeping exactly nine Core MCP tools.
+
+### Changed
+
+- Cloud release CI now runs optional real-server interoperability after the normal deterministic fake-LSP test/build gate on Linux, macOS, and Windows. Executable preflight now distinguishes a runnable Language server from PATH shims/proxies that exist but fail to launch, so incomplete rustup components are skipped rather than misreported as installed servers.
+- Local `release:verify` now includes an isolated Node 22.19.0 parity sandbox with its own `npm ci` and focused LSP/release regression suite; cloud CI and publication use the same Node 22.19.0 runtime to reduce local/cloud drift, while Windows test cleanup retries transient locked-directory removal.
+- Completed the 0.4 LSP v1 user, configuration, roadmap, contributor, and explicit Language-server example documentation, and hardened cross-platform/concurrency acceptance timing exposed during final release validation.
+
+## [0.4.5] - 2026-08-11
+
+### Added
+
+- Added Host-to-LSP cancellation propagation, bounded per-service semantic concurrency/queueing, and stable request timeout/cancellation/capacity errors without exposing arbitrary Agent-controlled timeout values.
+- Added aggregate Language-service runtime telemetry for service/process/request/document/diagnostic/stderr retention without logging source contents or paths.
+
+### Changed
+
+- Language services now retry one unexpected server crash, enter a bounded cooldown after repeated crashes, and invalidate only affected services when the effective server-definition fingerprint changes.
+- Language-service lifecycle now distinguishes truly idle services from cancellation-ignoring requests, evicts only the least-recently-used safe idle service at capacity, shares one service across logical workspaces on the same physical project, and releases managed-worktree services before finalization.
+- Idle shutdown and repeated open/query/config/crash cycles now explicitly release and bound server processes, synchronized documents, diagnostic snapshots, request state, stderr tails, and service counts.
+
 ## [0.4.4] - 2026-08-11
 
 ### Added

package/README.md

@@ -112,6 +112,22 @@ reports a semantic capability but the Host still shows an older tool snapshot,
 refresh or reconnect the integration rather than assuming the capability is
 missing from ForgeRelay.
 
+## LSP code intelligence
+
+ForgeRelay 0.4 LSP v1 exposes semantic code navigation through the
+`code.intelligence` Capability without adding language-specific top-level MCP tools.
+The v1 operations are definition, hover/type information, references, document
+symbols, workspace symbols, and diagnostics. Results use ForgeRelay-owned normalized
+locations, ranges, symbols, hover content, and diagnostic shapes rather than raw LSP
+wire unions.
+
+Language servers remain external dependencies. ForgeRelay can discover
+`typescript-language-server`, `pyright-langserver`, `rust-analyzer`, `gopls`, and
+`clangd` when they already exist on `PATH`, or use structured project/global
+configuration, but it never installs a server automatically. See
+[Configuration Reference](docs/configuration.md#lsp-code-intelligence) and
+[`examples/language-servers.json`](examples/language-servers.json).
+
 ## Worktrees without the usual cleanup mess
 
 A new managed worktree gets its own `forgerelay/*` branch instead of a detached
@@ -247,13 +263,13 @@ forgerelay doctor
 
 ## Where ForgeRelay is going
 
-The next additions are focused on making the local execution layer more useful,
-not on turning ForgeRelay into another all-in-one agent framework:
+With LSP code intelligence established in the 0.4 line, the next additions remain
+focused on making the local execution layer more useful, not on turning ForgeRelay
+into another all-in-one agent framework:
 
-1. LSP-backed code intelligence;
-2. first-class MCP subagent delegation;
-3. stronger worktree verification and recovery;
-4. checkpoint/rewind and retention improvements.
+1. first-class MCP subagent delegation;
+2. stronger worktree verification and recovery;
+3. checkpoint/rewind and retention improvements.
 
 ForgeRelay does not plan to add its own shell sandbox, long-term memory system,
 or plugin marketplace. Conversation, planning, web access, and other host-native
@@ -277,10 +293,13 @@ npm run release:verify
 ```
 
 Daily branch pushes do not run cloud CI. When preparing a release, run the full
-local release verification first. Pushing a matching `vX.Y.Z` tag to
-`Akira-TL/forgerelay` is the only cloud CI and publish trigger: GitHub Actions
-runs the reusable multi-platform CI, then publishes `@akira-tl/forgerelay` and
-creates the matching GitHub Release only after CI succeeds.
+local release verification first. `release:verify` includes a focused parity pass
+in an isolated Node 22.19.0 environment with its own `npm ci`, matching the cloud
+CI runtime for native addons and high-risk LSP lifecycle tests. Pushing a matching
+`vX.Y.Z` tag to `Akira-TL/forgerelay` is the only cloud CI and publish trigger:
+GitHub Actions runs the reusable multi-platform CI, then publishes
+`@akira-tl/forgerelay` and creates the matching GitHub Release only after CI
+succeeds.
 
 See [Versioning and Release Management](docs/versioning.md) for the bootstrap and
 Trusted Publishing setup.

package/capabilities/code-intelligence/GUIDE.md

@@ -4,7 +4,7 @@ Use the `code.intelligence` Capability for read-only semantic code navigation ba
 
 ForgeRelay does not install Language servers. It discovers supported executables when available and accepts explicit definitions from the global ForgeRelay config or `<workspace>/.forgerelay/language-servers.json`. Project definitions override global definitions, and global definitions override built-in discovery. An explicit definition may disable discovery with `enabled: false`.
 
-ForgeRelay 0.4.4 adds `diagnostics` alongside `definition`, `hover`, `references`, `documentSymbols`, and `workspaceSymbols`. Position-based operations accept a workspace-relative source `path` plus 1-based `line` and `column` values. `documentSymbols` needs only `path` and an optional bounded `limit`. `workspaceSymbols` uses `path` to select the Language project/service and accepts a `query` plus optional `limit`; it does not merge multiple nested Language services. `diagnostics` uses `path` plus an optional bounded `limit`. Columns are Unicode code-point positions; ForgeRelay converts them to the position encoding negotiated with the Language server.
+ForgeRelay 0.4 LSP v1 exposes `definition`, `hover`, `references`, `documentSymbols`, `workspaceSymbols`, and `diagnostics`. Position-based operations accept a workspace-relative source `path` plus 1-based `line` and `column` values. `documentSymbols` needs only `path` and an optional bounded `limit`. `workspaceSymbols` uses `path` to select the Language project/service and accepts a `query` plus optional `limit`; it does not merge multiple nested Language services. `diagnostics` uses `path` plus an optional bounded `limit`. Columns are Unicode code-point positions; ForgeRelay converts them to the position encoding negotiated with the Language server.
 
 Code-intelligence results use ForgeRelay-owned shapes rather than raw LSP wire types. Definition returns normalized locations. Hover returns one `contents` string, an optional legacy `language`, and an optional ForgeRelay-normalized `range`; plaintext, Markdown `MarkupContent`, and supported legacy `MarkedString` payloads are normalized before reaching the Agent. References uses the same normalized location shape, defaults to `limit: 100`, and accepts limits up to 1000. Its result reports `returned`, `truncated`, and `total` when the complete Language-server response makes the total known.
 
@@ -15,3 +15,11 @@ Diagnostics use the same normalized result contract for push and pull providers.
 Semantic locations may identify External code locations outside the Workspace, but that does not expand ForgeRelay's allowed roots or grant the file tools permission to read those paths.
 
 Language-server definitions use structured process configuration rather than shell command strings. A project configuration entry may contain `command`, `args`, `env`, `languages`, `extensions`, `languageIdByExtension`, `projectMarkers`, and `enabled` fields. Use `languageIdByExtension` when one server definition covers multiple language IDs whose extensions do not map one-to-one by array position. The server command is launched directly without a shell.
+
+Semantic Language-server requests use an internal bounded deadline; the Agent contract does not expose arbitrary timeout controls. Host cancellation is propagated to in-flight LSP requests, and ForgeRelay bounds both per-service semantic concurrency and queued work. Document synchronization is serialized before semantic requests cross the concurrency gate, while independent semantic reads may execute concurrently after that barrier. A server that ignores cancellation keeps its underlying request slot occupied until it actually settles, preventing repeated cancellations from creating an unbounded set of pending JSON-RPC requests.
+
+An unexpected Language-server process exit fails its pending JSON-RPC work immediately instead of waiting for the semantic deadline. ForgeRelay discards that service and retries the current semantic operation at most once. A second consecutive crash for the same Language project/server-definition fingerprint enters a short cooldown before another process may be started; a successful retry clears the crash state. Effective server definitions are fingerprinted, so a changed project/global/built-in definition selects a new service identity on the next code-intelligence resolution and retires only an idle service with the same project root/server id but the old fingerprint. ForgeRelay does not add a recursive config watcher.
+
+Language services are shared by physical Language project identity rather than logical Workspace id, so multiple conversations over the same checkout do not multiply server processes. Idle services are reclaimed after a bounded TTL, and the global service cap evicts the least-recently-used truly idle service; a request that has returned to the Host but whose server ignored cancellation still counts as active until the underlying LSP request settles. Managed-worktree finalization releases idle Language services rooted in that worktree before removing it and refuses finalization while semantic work is still active. Debug runtime telemetry reports only aggregate service/process/request/document/diagnostic/stderr counts and never source contents.
+
+The built-in discovery candidates are `typescript-language-server`, `pyright-langserver`, `rust-analyzer`, `gopls`, and `clangd`. Contributors can run `npm run lsp:interop` to exercise any of those executables that are already present on `PATH`; each detected server is tested through built-in discovery and real stdio LSP, while absent servers are reported as explicit skips. The interoperability check never downloads or installs a Language server.

package/dist/capability-registry.js

@@ -79,7 +79,7 @@ export class CapabilityRegistry {
             throw new CapabilityError("invalid_arguments", `Invalid arguments for capability ${name}: ${details}`);
         }
         try {
-            return await definition.run(parsed.data, context);
+            return await definition.run(parsed.data, context, options);
         }
         catch (error) {
             if (error instanceof CapabilityError)
@@ -186,7 +186,7 @@ export function createCapabilityRegistry(dependencies) {
                         available: dependencies.codeIntelligence?.available ?? false,
                         reason: dependencies.codeIntelligence?.unavailableReason,
                     }),
-                    run: async (input, context) => dependencies.codeIntelligence.run(input, context),
+                    run: async (input, context, options) => dependencies.codeIntelligence.run(input, context, options),
                 }]
             : []),
         ...(dependencies.downloadArtifact

package/dist/logger.js

@@ -223,7 +223,17 @@ function formatRuntimeResources(entry) {
     const completed = numberField(entry.processesCompleted) ?? 0;
     const workspaces = numberField(entry.cachedWorkspaces) ?? 0;
     const reviewStates = numberField(entry.reviewStates) ?? 0;
-    return `runtime rss=${rssMb}MB heap=${heapUsedMb}/${heapTotalMb}MB transports=${transports} processes=${running} running/${completed} completed workspaces=${workspaces} review=${reviewStates}`;
+    const languageServices = numberField(entry.languageServices) ?? 0;
+    const languageServicesActive = numberField(entry.languageServicesActive) ?? 0;
+    const languageProcesses = numberField(entry.languageProcessesRunning) ?? 0;
+    const languageRequestsActive = numberField(entry.languageRequestsActive) ?? 0;
+    const languageRequestsQueued = numberField(entry.languageRequestsQueued) ?? 0;
+    const languageDocuments = numberField(entry.languageOpenDocuments) ?? 0;
+    const languageDiagnosticSnapshots = numberField(entry.languageDiagnosticSnapshots) ?? 0;
+    const languageDiagnosticsRetained = numberField(entry.languageDiagnosticsRetained) ?? 0;
+    const languageStderrBytes = numberField(entry.languageStderrBytes) ?? 0;
+    const languageCooldowns = numberField(entry.languageCrashCooldowns) ?? 0;
+    return `runtime rss=${rssMb}MB heap=${heapUsedMb}/${heapTotalMb}MB transports=${transports} processes=${running} running/${completed} completed workspaces=${workspaces} review=${reviewStates} lsp=${languageServices} services/${languageServicesActive} active/${languageProcesses} processes requests=${languageRequestsActive} active/${languageRequestsQueued} queued docs=${languageDocuments} diagnostics=${languageDiagnosticSnapshots} snapshots/${languageDiagnosticsRetained} retained stderr=${languageStderrBytes}B cooldowns=${languageCooldowns}`;
 }
 function bytesToMegabytes(value) {
     return value === undefined ? 0 : Math.round(value / (1024 * 1024));

package/dist/lsp/code-intelligence.js

@@ -3,7 +3,7 @@ import { readFile, realpath } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createMessageConnection } from "vscode-jsonrpc/node";
-import { DefinitionRequest, DocumentDiagnosticReportKind, DocumentDiagnosticRequest, DocumentSymbolRequest, DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, PublishDiagnosticsNotification, ShutdownRequest, TextDocumentSyncKind, WorkspaceSymbolRequest, } from "vscode-languageserver-protocol";
+import { DefinitionRequest, DocumentDiagnosticReportKind, DocumentDiagnosticRequest, DocumentSymbolRequest, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, PublishDiagnosticsNotification, ShutdownRequest, WorkspaceSymbolRequest, } from "vscode-languageserver-protocol";
 import { LanguageServerConfigurationError, } from "./language-server-config.js";
 import { terminateProcessTree } from "../process-platform.js";
 import { CodeIntelligenceError } from "./code-intelligence-error.js";
@@ -11,8 +11,10 @@ import { DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT } from "./code-intelligence-type
 import { normalizeHoverContents } from "./normalization/hover.js";
 import { normalizeDocumentSymbols, normalizeWorkspaceSymbols, } from "./normalization/symbols.js";
 import { isWithin, locationEntries, normalizeLocations, workspaceDisplayPath, } from "./normalization/locations.js";
-import { lspPositionFromUser, rangeFromLsp, wholeDocumentRange } from "./position-encoding.js";
+import { lspPositionFromUser, rangeFromLsp } from "./position-encoding.js";
 import { DiagnosticSnapshotStore } from "./runtime/diagnostic-snapshots.js";
+import { DocumentSynchronizer } from "./runtime/document-synchronizer.js";
+import { SemanticRequestCoordinator } from "./runtime/semantic-requests.js";
 export { CodeIntelligenceError } from "./code-intelligence-error.js";
 const STDERR_TAIL_BYTES = 64 * 1024;
 export class LanguageService {
@@ -27,8 +29,9 @@ export class LanguageService {
     initializePromise;
     positionEncoding = PositionEncodingKind.UTF16;
     capabilities;
-    documents = new Map();
+    documents;
     diagnosticSnapshots;
+    semanticRequests;
     stderrTail = Buffer.alloc(0);
     closed = false;
     constructor(workspaceRoot, project, policy) {
@@ -36,7 +39,13 @@ export class LanguageService {
         this.project = project;
         this.policy = policy;
         this.key = languageServiceKey(project);
+        this.documents = new DocumentSynchronizer(project.definition);
         this.diagnosticSnapshots = new DiagnosticSnapshotStore(policy.maxDiagnosticDocuments, policy.maxDiagnosticsPerDocument);
+        this.semanticRequests = new SemanticRequestCoordinator({
+            maxConcurrent: policy.maxConcurrentSemanticRequests,
+            maxQueued: policy.maxQueuedSemanticRequests,
+            deadlineMs: policy.requestTimeoutMs,
+        });
     }
     acquire() {
         this.inFlight += 1;
@@ -46,19 +55,37 @@ export class LanguageService {
         this.inFlight = Math.max(0, this.inFlight - 1);
         this.lastUsedAt = Date.now();
     }
-    async definition(input) {
+    get isIdle() {
+        return this.inFlight === 0 &&
+            this.semanticRequests.activeCount === 0 &&
+            this.semanticRequests.queuedCount === 0;
+    }
+    get runtimeStats() {
+        const child = this.child;
+        return {
+            operationInFlight: this.inFlight,
+            semanticRequestsActive: this.semanticRequests.activeCount,
+            semanticRequestsQueued: this.semanticRequests.queuedCount,
+            openDocuments: this.documents.size,
+            diagnosticSnapshots: this.diagnosticSnapshots.size,
+            diagnosticsRetained: this.diagnosticSnapshots.retainedDiagnostics,
+            stderrBytes: this.stderrTail.length,
+            processRunning: Boolean(child && child.exitCode === null && child.signalCode === null),
+        };
+    }
+    async definition(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.definitionProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise definition support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(DefinitionRequest.type, {
+            const response = await this.semanticRequests.run(`Definition request for ${input.path}`, signal, (token) => this.connection.sendRequest(DefinitionRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Definition request timed out for ${input.path}.`));
+            }, token));
             const locations = await normalizeLocations(locationEntries(response), this.workspaceRoot, this.positionEncoding);
             return {
                 operation: "definition",
@@ -76,19 +103,19 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async hover(input) {
+    async hover(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.hoverProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise hover support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(HoverRequest.type, {
+            const response = await this.semanticRequests.run(`Hover request for ${input.path}`, signal, (token) => this.connection.sendRequest(HoverRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Hover request timed out for ${input.path}.`));
+            }, token));
             const common = {
                 operation: "hover",
                 selectedServer: this.project.definition.id,
@@ -114,20 +141,20 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async references(input) {
+    async references(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.referencesProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise references support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const position = lspPositionFromUser(document.text, input.line, input.column, this.positionEncoding);
-            const response = await withTimeout(this.connection.sendRequest(ReferencesRequest.type, {
+            const response = await this.semanticRequests.run(`References request for ${input.path}`, signal, (token) => this.connection.sendRequest(ReferencesRequest.type, {
                 textDocument: { uri: document.uri },
                 position,
                 context: { includeDeclaration: true },
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `References request timed out for ${input.path}.`));
+            }, token));
             const entries = locationEntries(response ?? []);
             const limit = input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT;
             const selected = entries.slice(0, limit);
@@ -151,17 +178,17 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async documentSymbols(input) {
+    async documentSymbols(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.documentSymbolProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise document-symbol support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
-            const response = await withTimeout(this.connection.sendRequest(DocumentSymbolRequest.type, {
+            const document = await this.syncDocumentOrdered(sourcePath);
+            const response = await this.semanticRequests.run(`Document-symbol request for ${input.path}`, signal, (token) => this.connection.sendRequest(DocumentSymbolRequest.type, {
                 textDocument: { uri: document.uri },
-            }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Document-symbol request timed out for ${input.path}.`));
+            }, token));
             const normalized = normalizeDocumentSymbols(response, document.text, this.positionEncoding, input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT);
             return {
                 operation: "documentSymbols",
@@ -176,15 +203,15 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async workspaceSymbols(input) {
+    async workspaceSymbols(input, signal) {
         try {
             await this.ensureStarted();
             if (!this.capabilities?.workspaceSymbolProvider) {
                 throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not advertise workspace-symbol support.`);
             }
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            await this.syncDocument(sourcePath);
-            const response = await withTimeout(this.connection.sendRequest(WorkspaceSymbolRequest.type, { query: input.query }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Workspace-symbol request timed out for ${JSON.stringify(input.query)}.`));
+            await this.syncDocumentOrdered(sourcePath);
+            const response = await this.semanticRequests.run(`Workspace-symbol request for ${JSON.stringify(input.query)}`, signal, (token) => this.connection.sendRequest(WorkspaceSymbolRequest.type, { query: input.query }, token));
             const normalized = await normalizeWorkspaceSymbols(response, this.workspaceRoot, this.positionEncoding, input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT);
             return {
                 operation: "workspaceSymbols",
@@ -199,11 +226,11 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
-    async diagnostics(input) {
+    async diagnostics(input, signal) {
         try {
             await this.ensureStarted();
             const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
-            const document = await this.syncDocument(sourcePath);
+            const document = await this.syncDocumentOrdered(sourcePath);
             const limit = input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT;
             const common = {
                 operation: "diagnostics",
@@ -214,11 +241,11 @@ export class LanguageService {
             const diagnosticProvider = this.capabilities?.diagnosticProvider;
             if (diagnosticProvider) {
                 const previousResultId = this.diagnosticSnapshots.previousPullResultId(document.uri);
-                const response = await withTimeout(this.connection.sendRequest(DocumentDiagnosticRequest.type, {
+                const response = await this.semanticRequests.run(`Diagnostic request for ${input.path}`, signal, (token) => this.connection.sendRequest(DocumentDiagnosticRequest.type, {
                     textDocument: { uri: document.uri },
                     ...(diagnosticProvider.identifier === undefined ? {} : { identifier: diagnosticProvider.identifier }),
                     ...(previousResultId === undefined ? {} : { previousResultId }),
-                }), this.policy.requestTimeoutMs, () => new CodeIntelligenceError("code.request_timeout", `Diagnostic request timed out for ${input.path}.`));
+                }, token));
                 if (response.kind === DocumentDiagnosticReportKind.Full) {
                     this.diagnosticSnapshots.capturePull(response.items, document, this.positionEncoding, response.resultId);
                 }
@@ -254,18 +281,7 @@ export class LanguageService {
         const connection = this.connection;
         const child = this.child;
         if (connection) {
-            for (const document of this.documents.values()) {
-                if (!document.openNotified)
-                    continue;
-                try {
-                    await connection.sendNotification(DidCloseTextDocumentNotification.type, {
-                        textDocument: { uri: document.uri },
-                    });
-                }
-                catch {
-                    // The server may already be gone.
-                }
-            }
+            await this.documents.closeAll(connection);
             try {
                 await withTimeout(connection.sendRequest(ShutdownRequest.type), this.policy.shutdownTimeoutMs, () => new Error("Language-server shutdown timed out."));
                 await connection.sendNotification(ExitNotification.type);
@@ -286,6 +302,9 @@ export class LanguageService {
         this.child = undefined;
         this.connection = undefined;
         this.initializePromise = undefined;
+        this.capabilities = undefined;
+        this.positionEncoding = PositionEncodingKind.UTF16;
+        this.stderrTail = Buffer.alloc(0);
     }
     async ensureStarted() {
         if (this.closed) {
@@ -335,6 +354,16 @@ export class LanguageService {
             onExitDuringInitialization = (code, signal) => reject(new CodeIntelligenceError("code.language_service_start_failed", `Language server ${definition.id} exited during initialization (${signal ?? code ?? "unknown"}).${this.stderrSuffix()}`));
             child.once("exit", onExitDuringInitialization);
         });
+        child.on("exit", () => {
+            if (this.closed || this.child !== child)
+                return;
+            try {
+                connection.dispose();
+            }
+            catch {
+                // Pending semantic requests will surface the unexpected process exit.
+            }
+        });
         const rootUri = pathToFileURL(this.project.projectRoot).href;
         const initializeParams = {
             processId: process.pid,
@@ -418,49 +447,8 @@ export class LanguageService {
             this.diagnosticSnapshots.capturePush(params, this.documents.get(params.uri), this.positionEncoding);
         });
     }
-    async syncDocument(sourcePath) {
-        const uri = pathToFileURL(sourcePath).href;
-        const text = await readFile(sourcePath, "utf8");
-        const existing = this.documents.get(uri);
-        const languageId = languageIdForPath(this.project.definition, sourcePath);
-        const synchronization = textDocumentSynchronization(this.capabilities?.textDocumentSync);
-        if (!existing) {
-            const document = { uri, languageId, version: 1, text, openNotified: false };
-            this.documents.set(uri, document);
-            if (synchronization.openClose) {
-                await this.connection.sendNotification(DidOpenTextDocumentNotification.type, {
-                    textDocument: {
-                        uri: document.uri,
-                        languageId: document.languageId,
-                        version: document.version,
-                        text: document.text,
-                    },
-                });
-                document.openNotified = true;
-            }
-            return document;
-        }
-        if (existing.text !== text) {
-            const previousText = existing.text;
-            existing.version += 1;
-            existing.text = text;
-            if (synchronization.change === TextDocumentSyncKind.Full) {
-                await this.connection.sendNotification(DidChangeTextDocumentNotification.type, {
-                    textDocument: { uri, version: existing.version },
-                    contentChanges: [{ text }],
-                });
-            }
-            else if (synchronization.change === TextDocumentSyncKind.Incremental) {
-                await this.connection.sendNotification(DidChangeTextDocumentNotification.type, {
-                    textDocument: { uri, version: existing.version },
-                    contentChanges: [{
-                            range: wholeDocumentRange(previousText, this.positionEncoding),
-                            text,
-                        }],
-                });
-            }
-        }
-        return existing;
+    async syncDocumentOrdered(sourcePath) {
+        return this.documents.sync(sourcePath, this.connection, this.capabilities?.textDocumentSync, this.positionEncoding);
     }
     appendStderr(chunk) {
         this.stderrTail = Buffer.concat([this.stderrTail, chunk]);
@@ -480,22 +468,6 @@ export function languageServiceKey(project) {
         project.definition.fingerprint,
     ]);
 }
-function languageIdForPath(definition, path) {
-    const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
-    return definition.languageIdByExtension[extension] ?? definition.languages[0];
-}
-function textDocumentSynchronization(value) {
-    if (typeof value === "number") {
-        return {
-            openClose: value !== TextDocumentSyncKind.None,
-            change: value,
-        };
-    }
-    return {
-        openClose: value?.openClose === true,
-        change: value?.change ?? TextDocumentSyncKind.None,
-    };
-}
 async function workspaceSourcePath(workspaceRoot, inputPath) {
     const root = resolve(workspaceRoot);
     const path = resolve(root, inputPath);

package/dist/lsp/runtime/diagnostic-snapshots.js

@@ -52,6 +52,14 @@ export class DiagnosticSnapshotStore {
     get size() {
         return this.pushSnapshots.size + this.pullSnapshots.size;
     }
+    get retainedDiagnostics() {
+        let total = 0;
+        for (const snapshot of this.pushSnapshots.values())
+            total += snapshot.diagnostics.length;
+        for (const snapshot of this.pullSnapshots.values())
+            total += snapshot.diagnostics.length;
+        return total;
+    }
     normalizeSnapshot(diagnostics, document, encoding, metadata) {
         return {
             diagnostics: diagnostics

package/dist/lsp/runtime/document-synchronizer.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, TextDocumentSyncKind, } from "vscode-languageserver-protocol";
+import { wholeDocumentRange } from "../position-encoding.js";
+export class DocumentSynchronizer {
+    definition;
+    documents = new Map();
+    queue = Promise.resolve();
+    constructor(definition) {
+        this.definition = definition;
+    }
+    get(uri) {
+        return this.documents.get(uri);
+    }
+    get size() {
+        return this.documents.size;
+    }
+    async sync(sourcePath, connection, synchronizationValue, positionEncoding) {
+        const operation = this.queue.then(() => this.syncNow(sourcePath, connection, synchronizationValue, positionEncoding), () => this.syncNow(sourcePath, connection, synchronizationValue, positionEncoding));
+        this.queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async closeAll(connection) {
+        await this.queue;
+        for (const document of this.documents.values()) {
+            if (!document.openNotified)
+                continue;
+            try {
+                await connection.sendNotification(DidCloseTextDocumentNotification.type, {
+                    textDocument: { uri: document.uri },
+                });
+            }
+            catch {
+                // The server may already be gone.
+            }
+        }
+    }
+    clear() {
+        this.documents.clear();
+        this.queue = Promise.resolve();
+    }
+    async syncNow(sourcePath, connection, synchronizationValue, positionEncoding) {
+        const uri = pathToFileURL(sourcePath).href;
+        const text = await readFile(sourcePath, "utf8");
+        const existing = this.documents.get(uri);
+        const languageId = languageIdForPath(this.definition, sourcePath);
+        const synchronization = textDocumentSynchronization(synchronizationValue);
+        if (!existing) {
+            const document = { uri, languageId, version: 1, text, openNotified: false };
+            this.documents.set(uri, document);
+            if (synchronization.openClose) {
+                await connection.sendNotification(DidOpenTextDocumentNotification.type, {
+                    textDocument: {
+                        uri: document.uri,
+                        languageId: document.languageId,
+                        version: document.version,
+                        text: document.text,
+                    },
+                });
+                document.openNotified = true;
+            }
+            return document;
+        }
+        if (existing.text !== text) {
+            const previousText = existing.text;
+            existing.version += 1;
+            existing.text = text;
+            if (synchronization.change === TextDocumentSyncKind.Full) {
+                await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+                    textDocument: { uri, version: existing.version },
+                    contentChanges: [{ text }],
+                });
+            }
+            else if (synchronization.change === TextDocumentSyncKind.Incremental) {
+                await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+                    textDocument: { uri, version: existing.version },
+                    contentChanges: [{
+                            range: wholeDocumentRange(previousText, positionEncoding),
+                            text,
+                        }],
+                });
+            }
+        }
+        return existing;
+    }
+}
+function languageIdForPath(definition, path) {
+    const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+    return definition.languageIdByExtension[extension] ?? definition.languages[0];
+}
+function textDocumentSynchronization(value) {
+    if (typeof value === "number") {
+        return {
+            openClose: value !== TextDocumentSyncKind.None,
+            change: value,
+        };
+    }
+    return {
+        openClose: value?.openClose === true,
+        change: value?.change ?? TextDocumentSyncKind.None,
+    };
+}