@hydranium/core 1.0.0-next.34 → 1.0.0-next.340

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

@@ -7,12 +7,18 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import type { CanonicalUri } from '@hydranium/protocol';
+import { type CanonicalUri, textHash } 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 { DocumentDirtyChangedEvent } from '../documents/dirty-state-tracker.js';
+import type {
+   ClientTextDocumentChangeEvent,
+   HydraniumTextDocuments,
+   DocumentReleasedEvent
+} 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` / `isReleaseDeferred` /
+ * `openDocuments`), the push channel
+ * to the language client (`applyEditToLanguageClient` / `stagePendingContent`),
+ * the save / close notifications, the dirty state (`isDirty` / `textState` /
+ * `onDidChangeDirty` / `setDiskBaseline`, 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,23 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'getAuthor'
    | 'isOpenInLanguageClient'
    | 'isOpenInAnyClient'
+   | 'isReleaseDeferred'
    | 'applyEditToLanguageClient'
    | 'stagePendingContent'
    | 'openDocuments'
+   | 'isOpenInClient'
+   | 'attachClient'
+   | 'registerSession'
+   | 'closeSession'
+   | 'onDidCloseSession'
+   | 'onDidReleaseDocument'
+   | 'isDirty'
+   | 'textState'
+   | 'openedVersion'
+   | 'onDidChangeDirty'
+   | 'setDiskBaseline'
+   | 'markCreated'
+   | 'isUnsavedCreation'
 > {
    /**
     * Stub-tailored read accessor. Returns just the surface the framework's
@@ -87,28 +112,46 @@ 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 `onDidReleaseDocument`
+    * when no client has `uri` open any more, then the dirty flip of a dropped
+    * holder: the real store's order. The stub keeps no release grace and runs
+    * no release handler, so the flip comes at once and without text, where the
+    * real store announces it once the handler settles, with text while the
+    * build still has the document.
+    */
    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 }[];
    /**
     * Decide what {@link applyEditToLanguageClient} answers, so a suite can drive
     * the rejection path (`{ applied: false }`) the real client takes when its
-    * buffer has outrun the version the push was addressed at. The call is still
-    * recorded in {@link appliedEdits} either way. Defaults to accepting.
+    * buffer has outrun the version the push was addressed at. The push is still
+    * recorded in {@link appliedEdits} either way. Defaults to accepting; not
+    * called for a URI not open in the language client.
     *
     * The handler runs INSIDE the call, which is also the only place a suite can
     * simulate something happening while the push is in flight — a newer settle,
     * a concurrent client edit.
     */
    setApplyEditHandler(handler: (uri: string, text: string) => ApplyWorkspaceEditResult | undefined): void;
-   /** Replay of every {@link applyEditToLanguageClient} call (the text channel to Monaco). */
+   /**
+    * Replay of every push {@link applyEditToLanguageClient} sent (the text
+    * channel to Monaco): none for a URI not seeded open in the language client,
+    * as the real store sends none.
+    */
    readonly appliedEdits: readonly { uri: string; text: string; label?: string }[];
    /** Replay of every {@link stagePendingContent} call (the not-yet-open staging path). */
    readonly staged: readonly { uri: string; text: string }[];
@@ -125,8 +168,38 @@ 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 documentReleased = new Emitter<DocumentReleasedEvent>();
+   const baselines = new Map<string, string | undefined>();
+   const created = new Set<string>();
+   const openedVersions = new Map<string, number>();
+   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);
+         }
+         // No build behind the stub, so a document no longer held is announced without text.
+         dirtyChanged.fire(
+            held === undefined
+               ? { uri: key(uri) }
+               : { uri: key(uri), text: { version: held.version, hash: textHash(held.text), dirty: now } }
+         );
+      }
+   };
 
-   return {
+   const stub: StubHydraniumTextDocuments = {
       get changes() {
          return changes;
       },
@@ -146,6 +219,13 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       version(uri) {
          return docs.get(uri)?.version ?? 0;
       },
+      openedVersion(uri) {
+         return docs.has(uri) ? openedVersions.get(uri) : undefined;
+      },
+      textState(uri) {
+         const held = docs.get(uri);
+         return held && { version: held.version, hash: textHash(held.text), dirty: dirty.has(uri) };
+      },
       notifyDidChangeTextDocument(event, clientId = LANGUAGE_CLIENT_ID) {
          const existing = docs.get(event.textDocument.uri);
          const next: StubTextDocumentEntry = {
@@ -159,6 +239,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 +253,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.setDiskBaseline(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,26 +292,74 @@ 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);
+      },
+      isReleaseDeferred() {
+         // The stub keeps no release grace.
+         return false;
+      },
+      attachClient(uri, clientId) {
+         return docs.has(uri) && sessions.addOpen(key(uri), clientId);
+      },
+      registerSession(clientId) {
+         sessions.register(clientId);
+      },
+      closeSession(clientId, cause) {
+         if (!sessions.isRegistered(clientId)) {
+            return;
+         }
+         try {
+            for (const uri of sessions.beginClose(clientId)) {
+               stub.fireClose(uri, clientId);
+            }
+         } finally {
+            sessions.unregister(clientId, cause);
          }
-         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 onDidReleaseDocument() {
+         return documentReleased.event;
+      },
+      isDirty(uri) {
+         return dirty.has(uri);
+      },
+      get onDidChangeDirty() {
+         return dirtyChanged.event;
+      },
+      setDiskBaseline(uri, text) {
+         if (docs.has(uri)) {
+            baselines.set(uri, text);
+            if (text !== undefined) {
+               created.delete(uri);
+            }
+            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] }));
+      },
+      markCreated(uri) {
+         if (docs.has(uri)) {
+            baselines.set(uri, undefined);
+            created.add(uri);
+            refreshDirty(uri);
+         }
+      },
+      isUnsavedCreation(uri) {
+         return created.has(uri);
+      },
+      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;
       },
       async applyEditToLanguageClient(uri, newText, options): Promise<ApplyWorkspaceEditResult | undefined> {
+         if (!languageClientOpen.has(uri)) {
+            return undefined;
+         }
          appliedEdits.push({ uri, text: newText, label: options?.label });
          return applyEditHandler(uri, newText);
       },
@@ -234,9 +367,14 @@ 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 });
+         openedVersions.set(uri, 1);
+         baselines.set(uri, text);
+         created.delete(uri);
       },
       seedOpenInLanguageClient(uri) {
+         sessions.addOpen(key(uri), LANGUAGE_CLIENT_ID);
          languageClientOpen.add(uri);
       },
       fireClose(uri, clientId) {
@@ -244,9 +382,12 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          // class: listeners detect the last-close transition by consulting
          // `isOpenInAnyClient`, which reads the already-decremented state.
          const holder = docs.get(uri);
-         if (holder && holder.clientId === clientId) {
+         const dropped = holder !== undefined && holder.clientId === clientId;
+         if (dropped) {
             docs.delete(uri);
+            created.delete(uri);
          }
+         const removed = sessions.removeOpen(key(uri), clientId);
          if (clientId === LANGUAGE_CLIENT_ID) {
             languageClientOpen.delete(uri);
          }
@@ -254,6 +395,13 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          for (const listener of closeListeners.slice()) {
             listener(event);
          }
+         if (removed && !sessions.isOpen(key(uri))) {
+            documentReleased.fire({ uri: key(uri) });
+         }
+         // After the release event, in the order the real store announces them.
+         if (dropped) {
+            refreshDirty(uri);
+         }
       },
       reset() {
          docs.clear();
@@ -262,9 +410,18 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          languageClientOpen.clear();
          appliedEdits.length = 0;
          staged.length = 0;
+         baselines.clear();
+         created.clear();
+         openedVersions.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,16 +53,16 @@ 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
- * subclass {@link ModelService} directly instead.
+ * surface is {@link DefaultModelService.rewriteModel} alongside `serialize` —
+ * should subclass {@link DefaultModelService} directly instead.
  */
 export function makeStubModelService<
    TAst extends AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement
 >(
    services: ServerSharedServices,

package/src/testing/stub-self-save-registry.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import type { SelfSaveRegistry } from '../documents/self-save-registry.js';
+import type { SelfSaveRegistry } from '../langium/workspace/self-save-registry.js';
 
 /**
  * Stub for the framework's {@link SelfSaveRegistry}. Records `register` calls

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

@@ -29,7 +29,7 @@ export interface StubLanguageDescriptor {
     * AST `$type`s this language's grammar produces. Synthesised into a minimal
     * `Grammar` — one entry-less parser rule per type — which is exactly what
     * `collectProducibleTypes` reads, so type→language routing
-    * (`buildLanguageTypeIndex`, `DataServer.resolveReferenceLanguage`) resolves
+    * (`buildLanguageTypeIndex`, `ExtendedServiceRegistry.getLanguageFor`) resolves
     * against this stub the same way it does against generated grammars.
     *
     * Entry-less on purpose: `reachableParserRules` falls back to every parser

package/src/testing/stub-writable-file-system.ts

@@ -8,7 +8,8 @@
  ********************************************************************************/
 
 import type { URI } from '@hydranium/langium';
-import type { WritableFileSystemProvider } from '../documents/ast-document-manager.js';
+import { SystemClock } from '@hydranium/protocol';
+import type { WritableFileSystemProvider } from '../langium/workspace/file-system-provider.js';
 import type { StubSelfSaveRegistry } from './stub-self-save-registry.js';
 
 /**
@@ -49,7 +50,7 @@ export function makeStubWritableFileSystem(selfSaveRegistry?: StubSelfSaveRegist
       readDirectory: async () => [],
       async writeFile(uri: URI, content: string) {
          writes.push({ uri: uri.toString(), content });
-         selfSaveRegistry?.register(uri.fsPath, Date.now());
+         selfSaveRegistry?.register(uri.fsPath, new SystemClock().now());
       },
       reset() {
          writes.length = 0;

package/src/util/connection-liveness.ts

@@ -7,41 +7,106 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
+import { describeError } from '@hydranium/protocol';
+
 /**
- * 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 errorCode(err) === DESTROYED_STREAM_CODE;
+}
+
+/** `err.code` where `err` is an `Error`, or `undefined` where reading it throws, as a getter or a revoked proxy can. */
+function errorCode(err: unknown): unknown {
+   try {
+      return err instanceof Error && 'code' in err ? err.code : undefined;
+   } catch {
+      return undefined;
+   }
+}
 
 /**
  * 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.
+ *
+ * Never throws, nor does {@link isClientGoneError}: a caller classifying a
+ * failure would otherwise lose it to a getter or proxy trap of the error.
  *
  * 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 {
-   const message = err instanceof Error ? err.message : String(err);
+   if (isDestroyedStreamError(err)) {
+      return true;
+   }
+   const message = describeError(err);
    const normalized = message.toLowerCase();
    return CONNECTION_GONE_PATTERNS.some(pattern => pattern.test(normalized));
 }
+
+const SOCKET_GONE_CODES = new Set(['EPIPE', 'ECONNRESET']);
+
+/** `write EPIPE` / `read ECONNRESET`, as a request's `ResponseError` copies the message. */
+const SOCKET_GONE_PATTERN = /\b(epipe|econnreset)\b/;
+
+/**
+ * Whether `err` means the client a connection serves has gone: what
+ * {@link isConnectionGoneError} recognises, or a write to a socket the client
+ * closed (`EPIPE`, `ECONNRESET`), matched by code or, for a request, by the
+ * code's name in the message.
+ *
+ * Only for a call whose errors can come from that connection alone. A socket
+ * error names no peer, so where a file system or another socket can fail the
+ * same call, it is a genuine failure and {@link isConnectionGoneError} is the
+ * one to ask.
+ */
+export function isClientGoneError(err: unknown): boolean {
+   if (isConnectionGoneError(err)) {
+      return true;
+   }
+   const code = errorCode(err);
+   if (typeof code === 'string' && SOCKET_GONE_CODES.has(code)) {
+      return true;
+   }
+   const message = describeError(err);
+   return SOCKET_GONE_PATTERN.test(message.toLowerCase());
+}

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
@@ -57,6 +65,20 @@ export function onProcessEvent(event: ProcessEvent, handler: (...args: unknown[]
    }
 }
 
+/**
+ * Whether a Node-like `process` exposes a writable standard error. A stricter
+ * test for Node than {@link processEnv}, since a bundler can shim
+ * `process.env` into a browser build without a writable stderr. `false`
+ * where reading the stderr throws, as a shim's getter can.
+ */
+export function hasProcessStderr(): boolean {
+   try {
+      return typeof process !== 'undefined' && !!process.stderr && typeof process.stderr.write === 'function';
+   } catch {
+      return false;
+   }
+}
+
 /**
  * Write already-formatted text to the process's standard error, when a
  * Node-like `process` exposes one. Returns `true` when the text was written and
@@ -69,7 +91,7 @@ export function onProcessEvent(event: ProcessEvent, handler: (...args: unknown[]
  * process inherits when it spawns a head as a child.
  */
 export function writeStderr(text: string): boolean {
-   if (typeof process === 'undefined' || !process.stderr || typeof process.stderr.write !== 'function') {
+   if (!hasProcessStderr()) {
       return false;
    }
    process.stderr.write(text);