@akira-tl/forgerelay 0.4.3 → 0.4.5

package/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [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
+
+- Added `code.intelligence` `diagnostics` with one normalized Agent-facing contract for traditional push diagnostics and LSP 3.17 pull diagnostics.
+- Added bounded latest Diagnostic snapshots with per-document freshness/version metadata, replacement/clear semantics, and no historical accumulation.
+
+### Changed
+
+- Pull diagnostics are preferred when a Language server advertises `diagnosticProvider`; ForgeRelay sends the previous `resultId`, handles `unchanged` reports, and keeps pull state independent from asynchronous push snapshots on mixed-capability servers.
+- Diagnostic collections reuse the 100 default / 1000 hard request limit while runtime caches independently bound document count and retained diagnostics per document. Filesystem synchronization makes stale push snapshots explicit and pull reports fresh against the synchronized document version.
+
 ## [0.4.3] - 2026-08-11
 
 ### Added

package/capabilities/code-intelligence/GUIDE.md

@@ -4,12 +4,20 @@ 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.3 supports `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. Columns are Unicode code-point positions; ForgeRelay converts them to the position encoding negotiated with the Language server.
+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.
 
 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.
 
 Document symbols preserve hierarchical server responses as a tree and keep flat `SymbolInformation` responses flat. Names, stable symbol-kind names, ranges, selection ranges, details, container names, and children are normalized without exposing LSP union types. Workspace symbols are always returned as a flat list with stable symbol metadata and normalized locations. Symbol limits use the same default 100 / hard maximum 1000 collection budget; document-symbol limits count total tree nodes, while workspace-symbol results report the server response total directly when known.
 
+Diagnostics use the same normalized result contract for push and pull providers. When a Language server advertises LSP pull diagnostics, ForgeRelay prefers pull, supplies the previous `resultId` when available, and treats an `unchanged` report as a refresh of the same bounded snapshot for the newly synchronized filesystem version. Otherwise ForgeRelay uses traditional `publishDiagnostics` snapshots. Push diagnostics retain only the latest snapshot for each synchronized document: no diagnostic history is accumulated. A result reports `provider`, bounded normalized diagnostics, `returned`/`truncated`/`total`, and `freshness`. `freshness.state` distinguishes fresh, stale, missing, and unknown snapshots; filesystem changes advance ForgeRelay's synchronized document version, making an older push snapshot detectably stale until the Language server publishes a replacement. Pull and push state are bounded independently so a mixed-capability server cannot overwrite pull `resultId` state with an asynchronous push. All diagnostic state is released with the Language service.
+
 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.

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)
@@ -140,6 +140,11 @@ export function createCapabilityRegistry(dependencies) {
             query: z.string(),
             limit: z.number().int().min(1).max(MAX_CODE_INTELLIGENCE_RESULT_LIMIT).optional(),
         }).strict(),
+        z.object({
+            operation: z.literal("diagnostics"),
+            path: z.string().min(1),
+            limit: z.number().int().min(1).max(MAX_CODE_INTELLIGENCE_RESULT_LIMIT).optional(),
+        }).strict(),
     ]);
     return new CapabilityRegistry([
         {
@@ -181,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, DocumentSymbolRequest, DidChangeTextDocumentNotification, DidCloseTextDocumentNotification, DidOpenTextDocumentNotification, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, 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,7 +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 {
@@ -26,7 +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) {
@@ -34,6 +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;
@@ -43,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",
@@ -73,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,
@@ -111,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);
@@ -148,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",
@@ -173,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",
@@ -196,6 +226,54 @@ export class LanguageService {
             throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
         }
     }
+    async diagnostics(input, signal) {
+        try {
+            await this.ensureStarted();
+            const sourcePath = await workspaceSourcePath(this.workspaceRoot, input.path);
+            const document = await this.syncDocumentOrdered(sourcePath);
+            const limit = input.limit ?? DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT;
+            const common = {
+                operation: "diagnostics",
+                selectedServer: this.project.definition.id,
+                projectRoot: workspaceDisplayPath(this.workspaceRoot, this.project.projectRoot),
+                path: workspaceDisplayPath(this.workspaceRoot, sourcePath),
+            };
+            const diagnosticProvider = this.capabilities?.diagnosticProvider;
+            if (diagnosticProvider) {
+                const previousResultId = this.diagnosticSnapshots.previousPullResultId(document.uri);
+                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 }),
+                }, token));
+                if (response.kind === DocumentDiagnosticReportKind.Full) {
+                    this.diagnosticSnapshots.capturePull(response.items, document, this.positionEncoding, response.resultId);
+                }
+                else if (!this.diagnosticSnapshots.markPullUnchanged(document, response.resultId)) {
+                    throw new CodeIntelligenceError("code.result_outside_policy", `Language server ${this.project.definition.id} returned unchanged diagnostics without a previous full report.`);
+                }
+                return {
+                    ...common,
+                    provider: "pull",
+                    ...this.diagnosticSnapshots.readPull(document, limit),
+                };
+            }
+            const snapshot = this.diagnosticSnapshots.readPush(document, limit);
+            if (snapshot.freshness.state === "missing" && !this.diagnosticSnapshots.hasObservedPushDiagnostics()) {
+                throw new CodeIntelligenceError("code.operation_unsupported", `Language server ${this.project.definition.id} does not provide pull diagnostics and has not published push diagnostics.`);
+            }
+            return {
+                ...common,
+                provider: "push",
+                ...snapshot,
+            };
+        }
+        catch (error) {
+            if (error instanceof CodeIntelligenceError)
+                throw error;
+            throw new CodeIntelligenceError("code.server_crashed", `Language server ${this.project.definition.id} failed: ${errorMessage(error)}${this.stderrSuffix()}`);
+        }
+    }
     async shutdown() {
         if (this.closed)
             return;
@@ -203,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);
@@ -228,12 +295,16 @@ export class LanguageService {
             connection.dispose();
         }
         this.documents.clear();
+        this.diagnosticSnapshots.clear();
         if (child && child.exitCode === null && child.signalCode === null) {
             terminateProcessTree(child, "SIGTERM", process.platform !== "win32");
         }
         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) {
@@ -283,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,
@@ -324,6 +405,10 @@ export class LanguageService {
                         dynamicRegistration: false,
                         hierarchicalDocumentSymbolSupport: true,
                     },
+                    diagnostic: {
+                        dynamicRegistration: false,
+                        relatedDocumentSupport: false,
+                    },
                 },
             },
         };
@@ -347,6 +432,7 @@ export class LanguageService {
         this.connection = undefined;
         this.child = undefined;
         this.documents.clear();
+        this.diagnosticSnapshots.clear();
     }
     registerClientHandlers(connection) {
         connection.onRequest("workspace/configuration", (params) => Array.isArray(params?.items) ? params.items.map(() => null) : []);
@@ -357,50 +443,12 @@ export class LanguageService {
         connection.onRequest("window/showMessageRequest", () => null);
         connection.onNotification("window/logMessage", () => undefined);
         connection.onNotification("window/showMessage", () => undefined);
+        connection.onNotification(PublishDiagnosticsNotification.type, (params) => {
+            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]);
@@ -420,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/normalization/diagnostics.js

@@ -0,0 +1,29 @@
+import { rangeFromLsp } from "../position-encoding.js";
+export function normalizeDiagnostic(diagnostic, documentText, encoding) {
+    return {
+        range: rangeFromLsp(documentText, diagnostic.range, encoding),
+        ...(diagnostic.severity === undefined ? {} : { severity: diagnosticSeverityName(diagnostic.severity) }),
+        ...(diagnostic.code === undefined ? {} : { code: diagnostic.code }),
+        ...(diagnostic.source === undefined ? {} : { source: diagnostic.source }),
+        message: typeof diagnostic.message === "string" ? diagnostic.message : diagnostic.message.value,
+        ...(diagnostic.tags?.length
+            ? { tags: diagnostic.tags.map(diagnosticTagName) }
+            : {}),
+    };
+}
+function diagnosticSeverityName(value) {
+    switch (value) {
+        case 1: return "error";
+        case 2: return "warning";
+        case 3: return "information";
+        case 4: return "hint";
+        default: return `unknown:${value}`;
+    }
+}
+function diagnosticTagName(value) {
+    switch (value) {
+        case 1: return "unnecessary";
+        case 2: return "deprecated";
+        default: return `unknown:${value}`;
+    }
+}

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

@@ -0,0 +1,113 @@
+import { normalizeDiagnostic } from "../normalization/diagnostics.js";
+export class DiagnosticSnapshotStore {
+    maxDocuments;
+    maxDiagnosticsPerDocument;
+    pushSnapshots = new Map();
+    pullSnapshots = new Map();
+    pushObserved = false;
+    constructor(maxDocuments, maxDiagnosticsPerDocument) {
+        this.maxDocuments = maxDocuments;
+        this.maxDiagnosticsPerDocument = maxDiagnosticsPerDocument;
+    }
+    capturePush(params, document, encoding) {
+        this.pushObserved = true;
+        if (!document)
+            return;
+        const snapshot = this.normalizeSnapshot(params.diagnostics, document, encoding, params.version === undefined ? {} : { publishedVersion: params.version });
+        this.setBounded(this.pushSnapshots, params.uri, snapshot);
+    }
+    capturePull(diagnostics, document, encoding, resultId) {
+        const snapshot = this.normalizeSnapshot(diagnostics, document, encoding, resultId === undefined ? {} : { resultId });
+        this.setBounded(this.pullSnapshots, document.uri, snapshot);
+    }
+    markPullUnchanged(document, resultId) {
+        const previous = this.pullSnapshots.get(document.uri);
+        if (!previous)
+            return false;
+        const snapshot = {
+            ...previous,
+            snapshotDocumentVersion: document.version,
+            resultId,
+        };
+        this.setBounded(this.pullSnapshots, document.uri, snapshot);
+        return true;
+    }
+    previousPullResultId(uri) {
+        return this.pullSnapshots.get(uri)?.resultId;
+    }
+    readPush(document, limit) {
+        return this.read(this.pushSnapshots, document, limit, true);
+    }
+    readPull(document, limit) {
+        return this.read(this.pullSnapshots, document, limit, false);
+    }
+    hasObservedPushDiagnostics() {
+        return this.pushObserved;
+    }
+    clear() {
+        this.pushSnapshots.clear();
+        this.pullSnapshots.clear();
+        this.pushObserved = false;
+    }
+    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
+                .slice(0, this.maxDiagnosticsPerDocument)
+                .map((diagnostic) => normalizeDiagnostic(diagnostic, document.text, encoding)),
+            total: diagnostics.length,
+            snapshotDocumentVersion: document.version,
+            ...metadata,
+        };
+    }
+    setBounded(snapshots, uri, snapshot) {
+        snapshots.delete(uri);
+        snapshots.set(uri, snapshot);
+        while (snapshots.size > this.maxDocuments) {
+            const oldestUri = snapshots.keys().next().value;
+            if (!oldestUri)
+                break;
+            snapshots.delete(oldestUri);
+        }
+    }
+    read(snapshots, document, limit, usePublishedVersion) {
+        const snapshot = snapshots.get(document.uri);
+        if (!snapshot) {
+            return {
+                diagnostics: [],
+                returned: 0,
+                truncated: false,
+                freshness: {
+                    state: "missing",
+                    documentVersion: document.version,
+                },
+            };
+        }
+        const diagnostics = snapshot.diagnostics.slice(0, limit);
+        const freshness = usePublishedVersion && snapshot.publishedVersion !== undefined
+            ? (snapshot.publishedVersion === document.version ? "fresh" : "stale")
+            : (snapshot.snapshotDocumentVersion === document.version ? "fresh" : "stale");
+        return {
+            diagnostics,
+            returned: diagnostics.length,
+            truncated: snapshot.total > diagnostics.length,
+            total: snapshot.total,
+            freshness: {
+                state: freshness,
+                documentVersion: document.version,
+                snapshotDocumentVersion: snapshot.snapshotDocumentVersion,
+                ...(snapshot.publishedVersion === undefined ? {} : { publishedVersion: snapshot.publishedVersion }),
+            },
+        };
+    }
+}