@hydranium/core 1.0.0-next.9 → 1.0.0-next.91

package/src/testing/playwright/flaky-network-proxy.ts

@@ -0,0 +1,240 @@
+/********************************************************************************
+ * 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 { createServer as createHttpServer, type Server as HttpServer } from 'node:http';
+import { connect, createServer as createTcpServer, type Server as TcpServer, type Socket } from 'node:net';
+
+/**
+ * A TCP proxy that can half-close a connection, so an e2e suite can reproduce a
+ * flaky network against a real browser session.
+ *
+ * Toggling the browser offline is not enough. On localhost the server sees the
+ * close immediately and reaps the socket before the browser reconnects, so the
+ * window where both sides disagree about the session — the one where reconnect
+ * defects live — never opens. Reaching it needs the browser's socket to die
+ * while the server still believes it is alive, and nothing inside the app or in
+ * Playwright's offline emulation can produce that asymmetry: both close cleanly
+ * at both ends.
+ *
+ * The proxy holds both halves of every connection and lets a test kill them
+ * independently:
+ *
+ *   `break`    destroy the BROWSER-side sockets, keep the server-side ones open.
+ *              The browser reconnects through a fresh pair while the server
+ *              still holds the old one.
+ *   `release`  destroy the orphaned server-side sockets `break` left. The
+ *              server's disconnect handler fires at once, rather than whenever
+ *              its next heartbeat write would have failed.
+ */
+
+/** Where the proxy listens, and the application it fronts. */
+export interface FlakyNetworkProxyOptions {
+   /** Port the browser connects to. */
+   readonly listenPort: number;
+   /** Port of the application being proxied. */
+   readonly targetPort: number;
+   /** Host of the application being proxied. Defaults to loopback. */
+   readonly targetHost?: string;
+   /** Port the HTTP control channel listens on. Defaults to `listenPort + 1000`. */
+   readonly controlPort?: number;
+}
+
+/** The commands the control channel accepts, and the proxy's own vocabulary. */
+export type FlakyNetworkCommand = 'break' | 'release' | 'status';
+
+/** Drives a running proxy. Implemented both in-process and over HTTP. */
+export interface FlakyNetworkControl {
+   /** Kill the browser side of every live connection; leave the server side up. */
+   break(): Promise<string>;
+   /** Kill the server side of every connection `break` orphaned. */
+   release(): Promise<string>;
+   /** How many connections are live and how many are orphaned. */
+   status(): Promise<string>;
+}
+
+export interface FlakyNetworkProxy extends FlakyNetworkControl {
+   /** Base URL a browser should be pointed at, i.e. Playwright's `baseURL`. */
+   readonly url: string;
+   /** Control channel, for workers that cannot reach this object directly. */
+   readonly controlUrl: string;
+   close(): Promise<void>;
+}
+
+interface ConnectionPair {
+   readonly id: number;
+   readonly browserSocket: Socket;
+   readonly targetSocket: Socket;
+   orphaned: boolean;
+}
+
+/**
+ * Starts the proxy in the calling process.
+ *
+ * Call it from a Playwright config, which runs in the main process before any
+ * worker forks. Workers are separate processes and cannot reach the returned
+ * object, which is what {@link controlUrl} and {@link flakyNetworkControlClient}
+ * are for.
+ */
+export async function startFlakyNetworkProxy(options: FlakyNetworkProxyOptions): Promise<FlakyNetworkProxy> {
+   const targetHost = options.targetHost ?? '127.0.0.1';
+   const controlPort = options.controlPort ?? options.listenPort + 1000;
+   const pairs = new Set<ConnectionPair>();
+   let sequence = 0;
+   let transcript: string[] = [];
+
+   const log = (message: string): void => {
+      transcript.push(message);
+      console.log(`[flaky-network] ${message}`);
+   };
+
+   const proxyServer: TcpServer = createTcpServer(browserSocket => {
+      const id = ++sequence;
+      const targetSocket = connect(options.targetPort, targetHost);
+      const pair: ConnectionPair = { id, browserSocket, targetSocket, orphaned: false };
+      pairs.add(pair);
+
+      // Forwarded by hand rather than with `pipe()`, so killing one side does not
+      // tear the other down — which is the entire point of the proxy.
+      browserSocket.on('data', chunk => {
+         if (!targetSocket.destroyed) {
+            targetSocket.write(chunk);
+         }
+      });
+      targetSocket.on('data', chunk => {
+         if (!pair.orphaned && !browserSocket.destroyed) {
+            browserSocket.write(chunk);
+         }
+      });
+
+      const teardown = (origin: 'browser' | 'target'): void => {
+         if (pair.orphaned && origin === 'browser') {
+            // Expected: `break` killed this side deliberately. The server side
+            // stays up until `release`.
+            return;
+         }
+         pairs.delete(pair);
+         browserSocket.destroy();
+         targetSocket.destroy();
+      };
+
+      browserSocket.on('close', () => teardown('browser'));
+      targetSocket.on('close', () => teardown('target'));
+      // A half-killed pair reliably raises ECONNRESET on the surviving side; an
+      // unhandled 'error' would take the whole runner down with it.
+      browserSocket.on('error', () => undefined);
+      targetSocket.on('error', () => undefined);
+   });
+
+   const commands: Record<FlakyNetworkCommand, () => void> = {
+      break: () => {
+         const live = [...pairs].filter(pair => !pair.orphaned);
+         if (live.length === 0) {
+            log('nothing to break');
+            return;
+         }
+         for (const pair of live) {
+            pair.orphaned = true;
+            pair.browserSocket.destroy();
+         }
+         log(`${live.length} connection(s) broken; the browser should reconnect shortly`);
+      },
+      release: () => {
+         const orphans = [...pairs].filter(pair => pair.orphaned);
+         if (orphans.length === 0) {
+            log('no orphaned connections; run `break` first');
+            return;
+         }
+         for (const pair of orphans) {
+            pairs.delete(pair);
+            pair.targetSocket.destroy();
+         }
+         log(`${orphans.length} orphaned connection(s) destroyed; their late disconnect fires now`);
+      },
+      status: () => {
+         const live = [...pairs].filter(pair => !pair.orphaned).length;
+         const orphaned = pairs.size - live;
+         log(`${live} live, ${orphaned} orphaned`);
+      }
+   };
+
+   const run = (name: string): string => {
+      transcript = [];
+      const command = commands[name as FlakyNetworkCommand];
+      if (command) {
+         command();
+      } else {
+         log(`unknown command '${name}'; use: ${Object.keys(commands).join(' | ')}`);
+      }
+      return transcript.join('\n');
+   };
+
+   const controlServer: HttpServer = createHttpServer((request, response) => {
+      const output = run((request.url ?? '').replace(/^\//, '').split('?')[0]);
+      response.writeHead(200, { 'content-type': 'text/plain' });
+      response.end(`${output}\n`);
+   });
+
+   await Promise.all([listen(proxyServer, options.listenPort), listen(controlServer, controlPort)]);
+   // Neither server keeps the process alive, so a runner that starts one from a
+   // config does not need a teardown hook to exit — and a caller that wants a
+   // deterministic shutdown still has `close()`.
+   proxyServer.unref();
+   controlServer.unref();
+
+   return {
+      url: `http://localhost:${options.listenPort}`,
+      controlUrl: `http://localhost:${controlPort}`,
+      break: async () => run('break'),
+      release: async () => run('release'),
+      status: async () => run('status'),
+      close: async () => {
+         for (const pair of pairs) {
+            pair.browserSocket.destroy();
+            pair.targetSocket.destroy();
+         }
+         pairs.clear();
+         await Promise.all([close(proxyServer), close(controlServer)]);
+      }
+   };
+}
+
+/**
+ * Drives a proxy running in another process, over its control channel.
+ *
+ * This is what a spec uses: Playwright workers are separate processes from the
+ * config that started the proxy.
+ */
+export function flakyNetworkControlClient(controlUrl: string): FlakyNetworkControl {
+   const send = async (command: FlakyNetworkCommand): Promise<string> => {
+      const response = await fetch(`${controlUrl}/${command}`);
+      if (!response.ok) {
+         throw new Error(`flaky-network proxy rejected '${command}': ${response.status}`);
+      }
+      return (await response.text()).trim();
+   };
+   return {
+      break: () => send('break'),
+      release: () => send('release'),
+      status: () => send('status')
+   };
+}
+
+function listen(server: TcpServer | HttpServer, port: number): Promise<void> {
+   return new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(port, () => {
+         server.off('error', reject);
+         resolve();
+      });
+   });
+}
+
+function close(server: TcpServer | HttpServer): Promise<void> {
+   return new Promise(resolve => server.close(() => resolve()));
+}

package/src/testing/playwright/index.ts

@@ -11,6 +11,7 @@
 // `@hydranium/core/testing` barrel) so importing the framework's unit-test
 // helpers never pulls in `@playwright/test` — which is an OPTIONAL peer here.
 export * from './e2e-profiling.js';
+export * from './flaky-network-proxy.js';
 export * from './browser-capture-bridge.js';
 export * from './server-log-capture.js';
 export * from './server-log-fixture.js';

package/src/testing/playwright/server-log-capture.ts

@@ -160,16 +160,28 @@ export function serverLogSpecName(file: string): string {
  * Rename each `<token>.log` (backend) and `<token>.browser.log` (forwarded
  * browser console) to the spec name recorded in its `<token>.spec` sidecar
  * (written by {@link markServerLog}), then delete the sidecar. Colliding names —
- * a spec that opened more than one workspace — get a `-2`, `-3`, … suffix. Token
- * logs without a sidecar are left untouched. Run once, after all server processes
- * have exited (e.g. a reporter's `onEnd`). Best-effort.
+ * a spec that opened more than one workspace — get a `-2`, `-3`, … suffix. Run
+ * once, after all server processes have exited (e.g. a reporter's `onEnd`).
+ * Best-effort.
+ *
+ * Returns the workspace tokens left UNATTRIBUTED — a log the capture wrote that
+ * no test claimed, because that spec never reached
+ * {@link markServerLog} (no `serverLog` fixture, no `beforeEach` call).
+ *
+ * **Returned rather than ignored, because the unattributed state is the
+ * misleading one.** Such a log still exists, still has content, and is named by
+ * an opaque token with no test boundaries in it — so a capture run that covered
+ * nothing looks exactly like one that covered everything, and the logs are
+ * there to be read. A caller that can warn should warn.
  */
-export function renameServerLogs(dir: string): void {
+export function renameServerLogs(dir: string): string[] {
    let entries: string[];
    try {
       entries = readdirSync(dir);
    } catch {
-      return;
+      // An unreadable capture dir has nothing to report — including nothing
+      // unattributed, since no log was observed at all.
+      return [];
    }
    // Per suffix (`.log`, `.browser.log`) a `taken` set guards collisions, so the
    // backend and browser logs for one spec share the same friendly base name.
@@ -190,6 +202,11 @@ export function renameServerLogs(dir: string): void {
          // ignore
       }
    };
+   // Every token the capture produced a backend log for, so the ones no sidecar
+   // claims can be reported rather than silently left behind.
+   const unattributed = new Set(
+      entries.filter(entry => entry.endsWith('.log') && !entry.endsWith('.browser.log')).map(entry => entry.slice(0, -'.log'.length))
+   );
    for (const entry of entries) {
       if (!entry.endsWith('.spec')) {
          continue;
@@ -210,9 +227,11 @@ export function renameServerLogs(dir: string): void {
       if (!name) {
          continue;
       }
+      unattributed.delete(token);
       rename(token, name, '.log');
       rename(token, name, '.browser.log');
    }
+   return [...unattributed];
 }
 
 /**

package/src/testing/playwright/server-log-rename-reporter.ts

@@ -24,6 +24,17 @@ export default class ServerLogRenameReporter {
    }
 
    onEnd(): void {
-      renameServerLogs(this.dir);
+      const unattributed = renameServerLogs(this.dir);
+      if (unattributed.length > 0) {
+         // Loud, because the alternative is a capture run that reads as
+         // complete: these logs exist and have content, but are named by an
+         // opaque workspace token and carry no test boundaries, so nothing
+         // about them says which spec they belong to.
+         console.warn(
+            `[server-log] ${unattributed.length} captured log(s) belong to no test: ${unattributed.join(', ')}.\n` +
+               '[server-log] Those specs never marked a boundary — apply the `serverLog` fixture, ' +
+               'or call `markServerLog`/`attachServerLog` from the suite, or their logs cannot be read per test.'
+         );
+      }
    }
 }

package/src/testing/stub-ast-document-manager.ts

@@ -9,8 +9,9 @@
 
 import { type AstNode, type LangiumDocument, UriUtils } from '@hydranium/langium';
 import { Disposable } from 'vscode-languageserver';
+import { type AstDiagnostic } from '../langium/validation/document-validator.js';
 import {
-   type AstDocument,
+   AstDocument,
    type AstDocumentManager,
    type AstDocumentUpdatedEvent,
    type WritableFileSystemProvider
@@ -27,9 +28,8 @@ import type { StubLangiumDocuments } from './stub-langium-documents.js';
  * underlying stub text-document manager, `onUpdate` is driven explicitly
  * through {@link StubAstDocumentManager.emitUpdate} because the stub tree runs
  * no build phases to emit from, and the remaining read helpers
- * (`isDirectChange`, `getAuthor`, `readFile`) throw if invoked — tests that
- * need them should wire a richer stub or use the real
- * {@link AstDocumentManager}.
+ * (`isTriggeringEdit`, `getAuthor`) throw if invoked — tests that need them
+ * should wire a richer stub or use the real {@link AstDocumentManager}.
  *
  * Open state is tracked per URI as the set of holding client ids, so a
  * document stays open until its last client closes. The stub forwards
@@ -45,7 +45,7 @@ import type { StubLangiumDocuments } from './stub-langium-documents.js';
  * are still picked so signature drift on them produces a compile
  * error rather than silent divergence.
  */
-export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic = unknown> extends Pick<
+export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic> extends Pick<
    AstDocumentManager<TAst, TDiagnostic>,
    | 'open'
    | 'close'
@@ -57,8 +57,7 @@ export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic = unkn
    | 'onClientClosed'
    | 'getAuthor'
    | 'getDocument'
-   | 'isDirectChange'
-   | 'readFile'
+   | 'isTriggeringEdit'
 > {
    readonly openClients: Map<string, Set<string>>;
 
@@ -104,7 +103,7 @@ export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic = unkn
    updateSubscriptions(uri?: string): number;
 }
 
-export function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic = unknown>(
+export function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic>(
    textDocuments: StubHydraniumTextDocuments,
    fileSystem: Pick<WritableFileSystemProvider, 'writeFile'>,
    documents?: StubLangiumDocuments<TAst, TDiagnostic>
@@ -193,7 +192,7 @@ export function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic = u
                return;
             }
             listener({
-               document: { uri, version: textDocuments.version(uri), root: undefined as unknown as TAst, diagnostics: [] as TDiagnostic[] },
+               document: AstDocument.create<TAst, TDiagnostic>(uri, textDocuments.version(uri), undefined as unknown as TAst),
                sourceClientId: event.clientId
             });
          });
@@ -214,11 +213,8 @@ export function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic = u
       getDocument(uri: string): LangiumDocument | undefined {
          return documents?.getDocument(UriUtils.toUri(uri));
       },
-      isDirectChange(): boolean {
-         return notSupported('isDirectChange');
-      },
-      async readFile(uri: string): Promise<string> {
-         return notSupported(`readFile(${uri})`);
+      isTriggeringEdit(): boolean {
+         return notSupported('isTriggeringEdit');
       }
    };
 }

package/src/testing/stub-document-builder.ts

@@ -9,6 +9,7 @@
 
 import {
    type DocumentBuilder,
+   type DocumentBuildListener,
    type DocumentPhaseListener,
    type DocumentState,
    type DocumentUpdateListener,
@@ -94,6 +95,14 @@ export interface StubDocumentBuilder extends Pick<
    firePhase(state: DocumentState, document: LangiumDocument, cancelToken?: CancellationToken): void;
    /** Synchronously fire every registered `onUpdate` listener. */
    fireOnUpdate(changed: URI[], deleted: URI[]): void;
+   /**
+    * Synchronously fire the BUILD-phase listener(s) for `state` with the whole
+    * batch. The per-build counterpart of {@link firePhase}: a subject that
+    * reports once per build rather than once per document subscribes here, and
+    * a stub that only fired {@link firePhase} would leave it silent while
+    * looking wired.
+    */
+   fireBuildPhase(state: DocumentState, built: LangiumDocument[], cancelToken?: CancellationToken): void;
    /**
     * Hold the next {@link waitUntil} call. The returned handle releases it;
     * the call's return value resolves on the next tick after `resolve` runs.
@@ -131,6 +140,7 @@ function reraise(result: unknown): void {
  */
 export function makeStubDocumentBuilder(): StubDocumentBuilder {
    const phaseListeners = new Map<DocumentState, DocumentPhaseListener[]>();
+   const buildPhaseListeners = new Map<DocumentState, DocumentBuildListener[]>();
    const onUpdateListeners: DocumentUpdateListener[] = [];
    const gates: Array<{ take(release: () => void): void }> = [];
    const updateCalls: RecordedBuilderCall<[URI[], URI[]]>[] = [];
@@ -194,6 +204,28 @@ export function makeStubDocumentBuilder(): StubDocumentBuilder {
             reraise(listener(changed, deleted));
          }
       },
+      onBuildPhase(state: DocumentState, listener: DocumentBuildListener) {
+         const list = buildPhaseListeners.get(state) ?? [];
+         list.push(listener);
+         buildPhaseListeners.set(state, list);
+         return Disposable.create(() => {
+            const idx = list.indexOf(listener);
+            if (idx >= 0) {
+               list.splice(idx, 1);
+            }
+         });
+      },
+      fireBuildPhase(state: DocumentState, built: LangiumDocument[], cancelToken?: CancellationToken) {
+         const token =
+            cancelToken ??
+            ({
+               isCancellationRequested: false,
+               onCancellationRequested: () => Disposable.create(() => undefined)
+            } as CancellationToken);
+         for (const listener of buildPhaseListeners.get(state) ?? []) {
+            reraise(listener(built, token));
+         }
+      },
       gateNextWaitUntil(): StubWaitUntilGate {
          let release: (() => void) | undefined;
          const entry = {
@@ -224,9 +256,6 @@ export function makeStubDocumentBuilder(): StubDocumentBuilder {
       build() {
          return notSupported('build');
       },
-      onBuildPhase() {
-         return notSupported('onBuildPhase');
-      },
       resetToState() {
          return notSupported('resetToState');
       },

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>;
 
@@ -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/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"}