@hydranium/core 1.0.0-next.18 → 1.0.0-next.180

package/src/testing/stub-hydranium-text-documents.ts

@@ -9,10 +9,16 @@
 
 import type { CanonicalUri } from '@hydranium/protocol';
 import type { ApplyWorkspaceEditResult } from 'vscode-languageserver';
-import { Disposable } from 'vscode-languageserver';
+import { Disposable, Emitter } from 'vscode-languageserver';
 import type { TextDocument } from 'vscode-languageserver-textdocument';
 import { LANGUAGE_CLIENT_ID } from '../documents/client-ids.js';
-import type { ClientTextDocumentChangeEvent, HydraniumTextDocuments } from '../documents/hydranium-text-documents.js';
+import { ClientSessionRegistry } from '../documents/client-session-registry.js';
+import type {
+   ClientTextDocumentChangeEvent,
+   DocumentDirtyChangedEvent,
+   HydraniumTextDocuments,
+   LastOpenClosedEvent
+} from '../documents/hydranium-text-documents.js';
 
 /** Snapshot of an open document tracked by the stub. */
 export interface StubTextDocumentEntry {
@@ -27,9 +33,14 @@ export interface StubTextDocumentEntry {
  * reads from on test paths — the content channel
  * (`notifyDidChangeTextDocument` / `applyContentChange` / `version` /
  * `getAuthor`), the open-state probes (`isOpenInLanguageClient` /
- * `isOpenInAnyClient` / `openDocuments`), the push channel to the language
- * client (`applyEditToLanguageClient` / `stagePendingContent`) and the
- * save / close notifications — plus test-only helpers:
+ * `isOpenInAnyClient` / `isOpenInClient` / `isRevertPending` /
+ * `openDocuments`), the push channel
+ * to the language client (`applyEditToLanguageClient` / `stagePendingContent`),
+ * the save / close notifications, the dirty state (`isDirty` /
+ * `onDidChangeDirty` / `updateDiskBaseline`, against a baseline {@link seedOpen}
+ * sets and a save that carries its text moves), and the client-session table
+ * (`registerSession` / `closeSession` / `onDidCloseSession`), which is a real
+ * `ClientSessionRegistry` — plus test-only helpers:
  *
  * - {@link seedOpen} — pre-populate an open document without firing change
  *   events. Use to set up a baseline version before exercising an `update`.
@@ -66,9 +77,19 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'getAuthor'
    | 'isOpenInLanguageClient'
    | 'isOpenInAnyClient'
+   | 'isRevertPending'
    | 'applyEditToLanguageClient'
    | 'stagePendingContent'
    | 'openDocuments'
+   | 'isOpenInClient'
+   | 'attachClient'
+   | 'registerSession'
+   | 'closeSession'
+   | 'onDidCloseSession'
+   | 'onDidCloseLastOpen'
+   | 'isDirty'
+   | 'onDidChangeDirty'
+   | 'updateDiskBaseline'
 > {
    /**
     * Stub-tailored read accessor. Returns just the surface the framework's
@@ -87,13 +108,23 @@ export interface StubHydraniumTextDocuments extends Pick<
    onDidSave(listener: (event: { document: { uri: string }; clientId: string }) => void): Disposable;
    /** Real-shaped close subscription — listener gets {@link ClientTextDocumentChangeEvent}. */
    onDidClose(listener: (event: ClientTextDocumentChangeEvent<TextDocument>) => void): Disposable;
-   /** Pre-populate an open document without firing change events. */
+   /** Pre-populate an open document without firing change events; `text` is also its disk baseline. */
    seedOpen(uri: string, text: string, clientId: string): void;
    /** Mark `uri` as open in the LSP textual language client (drives {@link isOpenInLanguageClient}). */
    seedOpenInLanguageClient(uri: string): void;
-   /** Synchronously deliver `onDidClose` to subscribers. */
+   /**
+    * Synchronously deliver `onDidClose` to subscribers, then `onDidCloseLastOpen`
+    * when no client has `uri` open any more. The stub keeps no revert grace, so
+    * a last close is announced at once.
+    */
    fireClose(uri: string, clientId: string): void;
-   /** Drop recorded state. Useful for `beforeEach` resets. */
+   /**
+    * Drop recorded state. Useful for `beforeEach` resets.
+    *
+    * Sessions end without announcing it, so a model service built on this
+    * stub still holds the handles it started before the reset. Build a fresh
+    * service after a reset rather than reusing one across it.
+    */
    reset(): void;
    readonly changes: readonly StubTextDocumentEntry[];
    readonly saves: readonly { uri: string; clientId: string }[];
@@ -125,8 +156,31 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
    let applyEditHandler: (uri: string, text: string) => ApplyWorkspaceEditResult | undefined = () => ({ applied: true });
    const saveListeners: Array<(event: { document: { uri: string }; clientId: string }) => void> = [];
    const closeListeners: Array<(event: ClientTextDocumentChangeEvent<TextDocument>) => void> = [];
+   // The real registry, so the session table, the opens and the closing state
+   // behave as the store's do. The stub's plain-string keys
+   // stand in for canonical URIs (one stub-boundary cast, like `fireClose`).
+   const sessions = new ClientSessionRegistry();
+   const key = (uri: string): CanonicalUri => uri as CanonicalUri;
+   const lastOpenClosed = new Emitter<LastOpenClosedEvent>();
+   const baselines = new Map<string, string | undefined>();
+   const dirty = new Set<string>();
+   const dirtyChanged = new Emitter<DocumentDirtyChangedEvent>();
+   // As the real store: dirty while held with text other than the baseline,
+   // announced only when the answer changes.
+   const refreshDirty = (uri: string): void => {
+      const held = docs.get(uri);
+      const now = held !== undefined && held.text !== baselines.get(uri);
+      if (now !== dirty.has(uri)) {
+         if (now) {
+            dirty.add(uri);
+         } else {
+            dirty.delete(uri);
+         }
+         dirtyChanged.fire({ uri: key(uri), dirty: now });
+      }
+   };
 
-   return {
+   const stub: StubHydraniumTextDocuments = {
       get changes() {
          return changes;
       },
@@ -159,6 +213,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          }
          docs.set(event.textDocument.uri, next);
          changes.push(next);
+         refreshDirty(event.textDocument.uri);
       },
       applyContentChange(uri, text, clientId) {
          const existing = docs.get(uri);
@@ -172,9 +227,13 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          const next: StubTextDocumentEntry = changed ? { uri, version: existing.version + 1, text, clientId } : existing;
          docs.set(uri, next);
          changes.push({ uri, version: next.version, text, clientId });
+         refreshDirty(uri);
          return next.version;
       },
       notifyDidSaveTextDocument(event, clientId) {
+         if (event.text !== undefined) {
+            stub.updateDiskBaseline(event.textDocument.uri, event.text);
+         }
          saves.push({ uri: event.textDocument.uri, clientId });
          for (const listener of saveListeners.slice()) {
             listener({ document: { uri: event.textDocument.uri }, clientId });
@@ -207,21 +266,52 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       isOpenInAnyClient(uri) {
          return docs.has(uri) || languageClientOpen.has(uri);
       },
-      openDocuments() {
-         // Merge the two seeding channels: `seedOpen` records the holding client
-         // on the doc entry, `seedOpenInLanguageClient` marks the LSP client.
-         const clientsByUri = new Map<string, Set<string>>();
-         for (const [uri, entry] of docs) {
-            clientsByUri.set(uri, new Set([entry.clientId]));
+      isOpenInClient(uri, clientId) {
+         return sessions.isOpenIn(key(uri), clientId);
+      },
+      isRevertPending(uri) {
+         return sessions.isRevertPending(key(uri));
+      },
+      attachClient(uri, clientId) {
+         return docs.has(uri) && sessions.addOpen(key(uri), clientId);
+      },
+      registerSession(clientId) {
+         sessions.register(clientId);
+      },
+      closeSession(clientId) {
+         if (!sessions.isRegistered(clientId)) {
+            return;
+         }
+         try {
+            for (const uri of sessions.beginClose(clientId)) {
+               stub.fireClose(uri, clientId);
+            }
+         } finally {
+            sessions.unregister(clientId);
          }
-         for (const uri of languageClientOpen) {
-            const clients = clientsByUri.get(uri) ?? new Set<string>();
-            clients.add(LANGUAGE_CLIENT_ID);
-            clientsByUri.set(uri, clients);
+      },
+      get onDidCloseSession() {
+         return sessions.onDidCloseSession;
+      },
+      get onDidCloseLastOpen() {
+         return lastOpenClosed.event;
+      },
+      isDirty(uri) {
+         return dirty.has(uri);
+      },
+      get onDidChangeDirty() {
+         return dirtyChanged.event;
+      },
+      updateDiskBaseline(uri, text) {
+         if (docs.has(uri)) {
+            baselines.set(uri, text);
+            refreshDirty(uri);
          }
-         // The real store keys by canonical identity; the stub's plain-string
-         // keys stand in for it (single stub-boundary cast, like `fireClose`).
-         return [...clientsByUri].map(([uri, clients]) => ({ uri: uri as CanonicalUri, clients: [...clients] }));
+      },
+      openDocuments() {
+         // From the registry that also answers `isOpenInClient`, which both
+         // seeding channels feed, so the two never disagree about an open.
+         return sessions.openDocuments();
       },
       setApplyEditHandler(handler) {
          applyEditHandler = handler;
@@ -234,9 +324,12 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          staged.push({ uri, text });
       },
       seedOpen(uri, text, clientId) {
+         sessions.addOpen(key(uri), clientId);
          docs.set(uri, { uri, version: 1, text, clientId });
+         baselines.set(uri, text);
       },
       seedOpenInLanguageClient(uri) {
+         sessions.addOpen(key(uri), LANGUAGE_CLIENT_ID);
          languageClientOpen.add(uri);
       },
       fireClose(uri, clientId) {
@@ -246,7 +339,9 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          const holder = docs.get(uri);
          if (holder && holder.clientId === clientId) {
             docs.delete(uri);
+            refreshDirty(uri);
          }
+         const removed = sessions.removeOpen(key(uri), clientId);
          if (clientId === LANGUAGE_CLIENT_ID) {
             languageClientOpen.delete(uri);
          }
@@ -254,6 +349,9 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          for (const listener of closeListeners.slice()) {
             listener(event);
          }
+         if (removed && !sessions.isOpen(key(uri))) {
+            lastOpenClosed.fire({ uri: key(uri) });
+         }
       },
       reset() {
          docs.clear();
@@ -262,9 +360,16 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          languageClientOpen.clear();
          appliedEdits.length = 0;
          staged.length = 0;
+         baselines.clear();
+         dirty.clear();
          saveListeners.length = 0;
          closeListeners.length = 0;
          applyEditHandler = () => ({ applied: true });
+         // Cleared in place rather than replaced: a model service built on the
+         // stub subscribed to `onDidCloseSession` once, and a new registry would
+         // leave that subscription on one nothing fires.
+         sessions.clear();
       }
    };
+   return stub;
 }

package/src/testing/stub-langium-documents.ts

@@ -9,6 +9,7 @@
 
 import { type AstNode, type LangiumDocument, type LangiumDocuments, stream, type URI } from '@hydranium/langium';
 import { makeFakeAstNode, makeFakeDocument, type FakeDocumentOptions } from './fake-document.js';
+import { type AstDiagnostic } from '../langium/validation/document-validator.js';
 
 /**
  * Map-backed stub for Langium's {@link LangiumDocuments} registry. Implements
@@ -31,7 +32,7 @@ import { makeFakeAstNode, makeFakeDocument, type FakeDocumentOptions } from './f
  * production code reads the slot value through the `LangiumDocuments`
  * interface and a narrowing cast bridges the stub at the binding site.
  */
-export interface StubLangiumDocuments<TAst extends AstNode = AstNode, TDiagnostic = unknown> extends Pick<
+export interface StubLangiumDocuments<TAst extends AstNode = AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic> extends Pick<
    LangiumDocuments,
    'getDocument' | 'hasDocument' | 'getOrCreateDocument' | 'all'
 > {
@@ -51,7 +52,7 @@ export interface StubLangiumDocuments<TAst extends AstNode = AstNode, TDiagnosti
  * Build a {@link StubLangiumDocuments}. Seed entries via the optional
  * `seeds` parameter so simple tests don't need a separate `set` call.
  */
-export function makeStubLangiumDocuments<TAst extends AstNode = AstNode, TDiagnostic = unknown>(
+export function makeStubLangiumDocuments<TAst extends AstNode = AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic>(
    seeds: ReadonlyArray<{ uri: string | URI; root: TAst; options?: FakeDocumentOptions<TAst, TDiagnostic> }> = []
 ): StubLangiumDocuments<TAst, TDiagnostic> {
    const docs = new Map<string, LangiumDocument<TAst>>();

package/src/testing/stub-model-service.ts

@@ -7,9 +7,10 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import type { TransferDiagnostic, TransferElement } from '@hydranium/protocol';
+import type { TransferElement } from '@hydranium/protocol';
+import type { AstDiagnostic } from '../langium/validation/document-validator.js';
 import type { AstNode } from '@hydranium/langium';
-import { ModelService, type ModelServiceOptions } from '../langium/model-service/model-service.js';
+import { DefaultModelService, type ModelService, type ModelServiceOptions } from '../langium/model-service/model-service.js';
 import type { ServerSharedServices } from '../langium/module.js';
 
 /**
@@ -21,9 +22,9 @@ import type { ServerSharedServices } from '../langium/module.js';
  */
 class StubModelServiceImpl<
    TAst extends AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement
-> extends ModelService<TAst, TDiagnostic, TTransfer> {
+> extends DefaultModelService<TAst, TDiagnostic, TTransfer> {
    constructor(
       services: ServerSharedServices,
       protected readonly serializeFn: (uri: string, root: TTransfer) => string,
@@ -40,7 +41,7 @@ class StubModelServiceImpl<
 /** The type of the model-service test double produced by {@link makeStubModelService}. */
 export type StubModelService<
    TAst extends AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement
 > = ModelService<TAst, TDiagnostic, TTransfer>;
 
@@ -52,8 +53,8 @@ export type StubModelService<
  * `makeTestServices` wires this stub automatically.
  *
  * `options` are the framework {@link ModelServiceOptions}, forwarded verbatim, so
- * a test can exercise an option-gated code path (`serializeBuilds`, the slow-warn
- * threshold) without hand-rolling a subclass just to reach the constructor.
+ * a test can exercise an option-gated code path (`allowReentrantBuilds`) without
+ * hand-rolling a subclass just to reach the constructor.
  *
  * Adopters that need richer override behaviour — the framework's own extension
  * surface is {@link ModelService.rewriteModel} alongside `serialize` — should
@@ -61,7 +62,7 @@ export type StubModelService<
  */
 export function makeStubModelService<
    TAst extends AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement
 >(
    services: ServerSharedServices,

package/src/util/connection-liveness.ts

@@ -8,39 +8,62 @@
  ********************************************************************************/
 
 /**
- * Phrases `vscode-jsonrpc` uses when a call loses its connection. Matched on the
- * message because the condition surfaces in two different shapes:
+ * Phrases that mean a call lost its connection. Matched on the message because
+ * the condition surfaces in shapes that share no discriminator:
  *
  * - a **throw** from `throwIfClosedOrDisposed` (`Connection is disposed.` /
  *   `Connection is closed.`), a `ConnectionError` raised synchronously by
  *   `sendRequest` / `sendNotification` and by `RemoteConsole.send`;
  * - a **rejection** of an already-issued request (`Pending response rejected
  *   since connection got disposed`), a `ResponseError` produced when the
- *   pending-response map is drained on teardown.
+ *   pending-response map is drained on teardown;
+ * - a **write into a destroyed transport** (`Cannot call write after a stream
+ *   was destroyed`), Node's own error for a message the writer queued before
+ *   the connection was disposed and flushed after its stream was destroyed.
+ *   A notification rejects with Node's error itself, which
+ *   {@link isDestroyedStreamError} catches by its code; a request rejects with
+ *   a `ResponseError` that copies only the message, so the phrase is needed
+ *   too.
  *
- * Both are typed, but they are different error classes carrying codes from
- * different enums, so no single code check covers both. Kept
- * lowercase-normalised and anchored on `connection` so an unrelated "disposed"
- * message cannot match.
+ * The typed errors come from different classes carrying codes from different
+ * enums, so no single code check covers them. Kept lowercase-normalised and
+ * anchored on `connection` or `stream` so an unrelated "disposed" message
+ * cannot match.
  */
-const CONNECTION_GONE_PATTERNS = [/connection is disposed/, /connection is closed/, /connection got disposed/, /connection got closed/];
+const CONNECTION_GONE_PATTERNS = [
+   /connection is disposed/,
+   /connection is closed/,
+   /connection got disposed/,
+   /connection got closed/,
+   /after a stream was destroyed/
+];
+
+const DESTROYED_STREAM_CODE = 'ERR_STREAM_DESTROYED';
+
+function isDestroyedStreamError(err: unknown): boolean {
+   return err instanceof Error && 'code' in err && err.code === DESTROYED_STREAM_CODE;
+}
 
 /**
  * Whether `err` means "the peer is gone", as opposed to a genuine failure of
  * the operation.
  *
- * The distinction is a **log-severity** one, and it matters because the two are
- * indistinguishable at the call site otherwise. Pushing an edit to a language
- * client that has already disconnected is a no-op, not a fault — it happens on
- * every ordinary shutdown, and reporting it at `error` turns routine teardown
- * into something that looks like it needs investigation. A real `applyEdit`
- * failure (the client refused, the request malformed) still deserves `error`.
+ * The two are indistinguishable at the call site otherwise, and callers act on
+ * the answer: a gone peer is logged at `debug` or dropped, a genuine failure is
+ * logged at `error` or re-raised as an unhandled rejection. Pushing an edit to
+ * a language client that has already disconnected is a no-op, not a fault — it
+ * happens on every ordinary shutdown — so a `false` here turns routine teardown
+ * into errors that look like they need investigation. A `true` for a real
+ * `applyEdit` failure (the client refused, the request malformed) hides it.
  *
  * Callers that only need to *survive* a dead connection rather than classify it
  * should just catch — see `LspLogger.emit`, whose fallback path does exactly
  * that, since a logger has nowhere to report a logging failure anyway.
  */
 export function isConnectionGoneError(err: unknown): boolean {
+   if (isDestroyedStreamError(err)) {
+      return true;
+   }
    const message = err instanceof Error ? err.message : String(err);
    const normalized = message.toLowerCase();
    return CONNECTION_GONE_PATTERNS.some(pattern => pattern.test(normalized));

package/src/util/environment.ts

@@ -44,7 +44,15 @@ export function isCaseInsensitiveFileSystem(): boolean {
 
 /** Node `process` lifecycle / error / signal events accepted by {@link onProcessEvent}. */
 export type ProcessEvent =
-   'exit' | 'beforeExit' | 'uncaughtException' | 'unhandledRejection' | 'rejectionHandled' | 'warning' | 'SIGINT' | 'SIGTERM' | 'SIGHUP';
+   | 'exit'
+   | 'beforeExit'
+   | 'uncaughtException'
+   | 'unhandledRejection'
+   | 'rejectionHandled'
+   | 'warning'
+   | 'SIGINT'
+   | 'SIGTERM'
+   | 'SIGHUP';
 
 /**
  * Register a process lifecycle handler (`'exit'`, `'unhandledRejection'`, …) if

package/lib/lsp/instrument-connection.d.ts

@@ -1,36 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-import type { LatencyCollector } from '@hydranium/protocol';
-/**
- * Wrap an LSP `Connection` so every request handler registered through
- * `onRequest` is timed into `latency` under its method name — the LSP analog of
- * the data-server RPC chokepoint. Langium's `startLanguageServer` registers
- * `onCompletion`/`onHover`/… one handler at a time, so there is no single
- * dispatch point; but every registration funnels through the ONE `onRequest`
- * on the shared `Connection`, so decorating it catches every method with no
- * Langium fork and no per-handler code.
- *
- * Opt in where the head creates the connection, before it hands it to the
- * services factory — wrapping it afterwards is too late, because Langium has
- * already registered its handlers against the raw connection.
- *
- * `onRequest` has several overloads: most register a handler for a specific
- * method (a string, or a typed request whose `.method` names it) and one is the
- * `StarRequestHandler` catch-all `onRequest(handler)`. The star form fires only
- * for methods with no registered handler, so timing it would be misleading — it
- * is passed through untouched. Every other member of the connection is
- * forwarded unchanged.
- *
- * When `latency` is `undefined` the seam is off: the connection is returned
- * unchanged (no Proxy, no per-request timing), so a head can pass the result of
- * an env-gated factory (`latencyFromEnv()`) straight through and pay nothing
- * when latency is not enabled.
- */
-export declare function instrumentLspConnection<C extends object>(connection: C, latency: LatencyCollector | undefined): C;
-//# sourceMappingURL=instrument-connection.d.ts.map

package/lib/lsp/instrument-connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instrument-connection.d.ts","sourceRoot":"","sources":["../../src/lsp/instrument-connection.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,GAAG,CAAC,CA2BjH"}

package/lib/lsp/instrument-connection.js

@@ -1,62 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-/**
- * Wrap an LSP `Connection` so every request handler registered through
- * `onRequest` is timed into `latency` under its method name — the LSP analog of
- * the data-server RPC chokepoint. Langium's `startLanguageServer` registers
- * `onCompletion`/`onHover`/… one handler at a time, so there is no single
- * dispatch point; but every registration funnels through the ONE `onRequest`
- * on the shared `Connection`, so decorating it catches every method with no
- * Langium fork and no per-handler code.
- *
- * Opt in where the head creates the connection, before it hands it to the
- * services factory — wrapping it afterwards is too late, because Langium has
- * already registered its handlers against the raw connection.
- *
- * `onRequest` has several overloads: most register a handler for a specific
- * method (a string, or a typed request whose `.method` names it) and one is the
- * `StarRequestHandler` catch-all `onRequest(handler)`. The star form fires only
- * for methods with no registered handler, so timing it would be misleading — it
- * is passed through untouched. Every other member of the connection is
- * forwarded unchanged.
- *
- * When `latency` is `undefined` the seam is off: the connection is returned
- * unchanged (no Proxy, no per-request timing), so a head can pass the result of
- * an env-gated factory (`latencyFromEnv()`) straight through and pay nothing
- * when latency is not enabled.
- */
-export function instrumentLspConnection(connection, latency) {
-    if (!latency) {
-        return connection;
-    }
-    return new Proxy(connection, {
-        get(target, property, receiver) {
-            const value = Reflect.get(target, property, receiver);
-            if (property !== 'onRequest' || typeof value !== 'function') {
-                return value;
-            }
-            const onRequest = value;
-            return (...args) => {
-                const [first, handler] = args;
-                // Star form `onRequest(handler)` — pass through; it is not a timer.
-                if (typeof first === 'function' || typeof handler !== 'function') {
-                    return onRequest.apply(target, args);
-                }
-                const method = typeof first === 'string' ? first : first.method;
-                if (typeof method !== 'string') {
-                    return onRequest.apply(target, args);
-                }
-                const original = handler;
-                const timed = (...handlerArgs) => latency.time(method, () => original(...handlerArgs));
-                return onRequest.apply(target, [first, timed, ...args.slice(2)]);
-            };
-        }
-    });
-}
-//# sourceMappingURL=instrument-connection.js.map

package/lib/lsp/instrument-connection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"instrument-connection.js","sourceRoot":"","sources":["../../src/lsp/instrument-connection.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAMlF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,uBAAuB,CAAmB,UAAa,EAAE,OAAqC;IAC3G,IAAI,CAAC,OAAO,EAAE,CAAC;QACZ,OAAO,UAAU,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,UAAU,EAAE;QAC1B,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ;YAC3B,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC/D,IAAI,QAAQ,KAAK,WAAW,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAC3D,OAAO,KAAK,CAAC;YAChB,CAAC;YACD,MAAM,SAAS,GAAG,KAAwC,CAAC;YAC3D,OAAO,CAAC,GAAG,IAAe,EAAW,EAAE;gBACpC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;gBAC9B,oEAAoE;gBACpE,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;oBAChE,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,KAA8B,CAAC,MAAM,CAAC;gBAC1F,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;oBAC9B,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,MAAM,QAAQ,GAAG,OAAyB,CAAC;gBAC3C,MAAM,KAAK,GAAmB,CAAC,GAAG,WAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;gBACvG,OAAO,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC;QACL,CAAC;KACH,CAAC,CAAC;AACN,CAAC"}

package/src/lsp/instrument-connection.ts

@@ -1,66 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the MIT License which is available in the project root.
- *
- * SPDX-License-Identifier: MIT
- ********************************************************************************/
-
-import type { LatencyCollector } from '@hydranium/protocol';
-
-type RequestHandler = (...args: unknown[]) => unknown;
-
-/**
- * Wrap an LSP `Connection` so every request handler registered through
- * `onRequest` is timed into `latency` under its method name — the LSP analog of
- * the data-server RPC chokepoint. Langium's `startLanguageServer` registers
- * `onCompletion`/`onHover`/… one handler at a time, so there is no single
- * dispatch point; but every registration funnels through the ONE `onRequest`
- * on the shared `Connection`, so decorating it catches every method with no
- * Langium fork and no per-handler code.
- *
- * Opt in where the head creates the connection, before it hands it to the
- * services factory — wrapping it afterwards is too late, because Langium has
- * already registered its handlers against the raw connection.
- *
- * `onRequest` has several overloads: most register a handler for a specific
- * method (a string, or a typed request whose `.method` names it) and one is the
- * `StarRequestHandler` catch-all `onRequest(handler)`. The star form fires only
- * for methods with no registered handler, so timing it would be misleading — it
- * is passed through untouched. Every other member of the connection is
- * forwarded unchanged.
- *
- * When `latency` is `undefined` the seam is off: the connection is returned
- * unchanged (no Proxy, no per-request timing), so a head can pass the result of
- * an env-gated factory (`latencyFromEnv()`) straight through and pay nothing
- * when latency is not enabled.
- */
-export function instrumentLspConnection<C extends object>(connection: C, latency: LatencyCollector | undefined): C {
-   if (!latency) {
-      return connection;
-   }
-   return new Proxy(connection, {
-      get(target, property, receiver): unknown {
-         const value: unknown = Reflect.get(target, property, receiver);
-         if (property !== 'onRequest' || typeof value !== 'function') {
-            return value;
-         }
-         const onRequest = value as (...args: unknown[]) => unknown;
-         return (...args: unknown[]): unknown => {
-            const [first, handler] = args;
-            // Star form `onRequest(handler)` — pass through; it is not a timer.
-            if (typeof first === 'function' || typeof handler !== 'function') {
-               return onRequest.apply(target, args);
-            }
-            const method = typeof first === 'string' ? first : (first as { method?: unknown }).method;
-            if (typeof method !== 'string') {
-               return onRequest.apply(target, args);
-            }
-            const original = handler as RequestHandler;
-            const timed: RequestHandler = (...handlerArgs) => latency.time(method, () => original(...handlerArgs));
-            return onRequest.apply(target, [first, timed, ...args.slice(2)]);
-         };
-      }
-   });
-}