@hydranium/core 1.0.0-next.11 → 1.0.0-next.112

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/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)]);
-         };
-      }
-   });
-}