@hydranium/core 1.0.0-next.24 → 1.0.0-next.242

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,21 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'getAuthor'
    | 'isOpenInLanguageClient'
    | 'isOpenInAnyClient'
+   | 'isReleaseDeferred'
    | 'applyEditToLanguageClient'
    | 'stagePendingContent'
    | 'openDocuments'
+   | 'isOpenInClient'
+   | 'attachClient'
+   | 'registerSession'
+   | 'closeSession'
+   | 'onDidCloseSession'
+   | 'onDidReleaseDocument'
+   | 'isDirty'
+   | 'textState'
+   | 'openedVersion'
+   | 'onDidChangeDirty'
+   | 'setDiskBaseline'
 > {
    /**
     * Stub-tailored read accessor. Returns just the surface the framework's
@@ -87,28 +110,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 +166,37 @@ 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 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 +216,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 +236,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 +250,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 +289,61 @@ 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;
          }
-         for (const uri of languageClientOpen) {
-            const clients = clientsByUri.get(uri) ?? new Set<string>();
-            clients.add(LANGUAGE_CLIENT_ID);
-            clientsByUri.set(uri, clients);
+         try {
+            for (const uri of sessions.beginClose(clientId)) {
+               stub.fireClose(uri, clientId);
+            }
+         } finally {
+            sessions.unregister(clientId, cause);
          }
-         // 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] }));
+      },
+      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);
+            refreshDirty(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 +351,13 @@ 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);
       },
       seedOpenInLanguageClient(uri) {
+         sessions.addOpen(key(uri), LANGUAGE_CLIENT_ID);
          languageClientOpen.add(uri);
       },
       fireClose(uri, clientId) {
@@ -244,9 +365,11 @@ 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);
          }
+         const removed = sessions.removeOpen(key(uri), clientId);
          if (clientId === LANGUAGE_CLIENT_ID) {
             languageClientOpen.delete(uri);
          }
@@ -254,6 +377,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 +392,17 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          languageClientOpen.clear();
          appliedEdits.length = 0;
          staged.length = 0;
+         baselines.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,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/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,7 @@
  ********************************************************************************/
 
 import type { URI } from '@hydranium/langium';
-import type { WritableFileSystemProvider } from '../documents/ast-document-manager.js';
+import type { WritableFileSystemProvider } from '../langium/workspace/file-system-provider.js';
 import type { StubSelfSaveRegistry } from './stub-self-save-registry.js';
 
 /**

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/documents/language-client-text-shadow.d.ts

@@ -1,101 +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 TextEdit } from 'vscode-languageserver';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-/**
- * The minimum surface the shadow needs from a `HydraniumTextDocuments`:
- * a `create` method that materialises a fresh text document via the
- * configured `TextDocumentsConfiguration`. Declared as a narrow
- * structural interface so the manager satisfies it without an explicit
- * import (sidestepping the circular `HydraniumTextDocuments → shadow → manager`
- * dependency) and so tests can stub it with a minimal object literal.
- */
-export interface ShadowDocumentSource {
-    create(uri: string, languageId: string, version: number, content: string): TextDocument;
-}
-/**
- * Whether `edits` is the single full-document replace {@link LanguageClientTextShadow.computeEdits}
- * emits when it has no usable baseline.
- *
- * The distinction matters at the `workspace/applyEdit` egress: a full replace is
- * position-INDEPENDENT and therefore lands correctly on any client buffer, while
- * a line-keyed diff only lands correctly on the exact text it was diffed
- * against. Only the latter needs a client-version gate.
- */
-export declare function isFullReplace(edits: readonly TextEdit[]): boolean;
-/**
- * Tracks the text content the language client (typically Monaco) is believed to
- * currently hold so outgoing `workspace/applyEdit` requests can ship minimal
- * diffs instead of full-document replaces.
- *
- * Why it matters: a full-range replace on a moderately-sized YAML or DSL source
- * forces Monaco to re-tokenise the entire document (observed multi-second hangs
- * on large diagrams), whereas line-level diffs usually reduce that to a handful
- * of small edits.
- *
- * Update points the caller is responsible for:
- *  - {@link computeEdits} after each outgoing server→client sync (updates the shadow optimistically).
- *  - {@link set} when the server receives a `didChange` from the language client (the client now
- *    holds that text; we shouldn't resend it).
- *  - {@link invalidate} when the client rejects an edit (`applied=false`) or a doc is closed —
- *    the shadow is now stale and the next sync must fall back to a full replace.
- */
-export declare class LanguageClientTextShadow {
-    protected onFallback: (uri: string, reason: string) => void;
-    protected documents: ShadowDocumentSource;
-    protected shadow: Map<string, string>;
-    /**
-     * @param onFallback invoked when {@link computeEdits} falls back to a full-range replace due to
-     *    apply-verify mismatch. Useful for logging regressions.
-     * @param documents the {@link ShadowDocumentSource} used to materialise the throwaway probe
-     *    document in {@link computeEdits}. In production this is the owning
-     *    `HydraniumTextDocuments` (whose `create` threads through its configured
-     *    `TextDocumentsConfiguration`); tests pass a minimal stub. Routing
-     *    through the manager rather than `TextDocument.create` directly avoids the
-     *    `instanceof FullTextDocument` gate in the bare LSP `TextDocument.update`,
-     *    keeping the verifier honest for adopters with a custom text-document type.
-     */
-    constructor(onFallback: (uri: string, reason: string) => void, documents: ShadowDocumentSource);
-    /** Record the text the language client is known to hold (e.g. after a `didChange` echo). */
-    set(uri: string, text: string): void;
-    /**
-     * The text the language client is believed to hold, or `undefined` when
-     * there is no baseline (first sync, or after an {@link invalidate}).
-     *
-     * Read at the `workspace/applyEdit` egress BEFORE {@link computeEdits},
-     * which overwrites it: a push's minimal edits are keyed to this text, so an
-     * echo of that push carries ranges addressing it and nothing else. Losing
-     * it is what makes an incremental echo unreconstructable, and applying such
-     * an echo to the already-advanced synced text duplicates every inserted
-     * line.
-     */
-    get(uri: string): string | undefined;
-    /** Forget the shadow for a URI; next {@link computeEdits} falls back to a full-document replace. */
-    invalidate(uri: string): void;
-    /**
-     * Return the minimal LSP {@link TextEdit}s required to bring the language client's content from
-     * the tracked shadow to `newText`. Updates the shadow to `newText` so subsequent calls diff
-     * against it.
-     *
-     *  - Empty array when the shadow already equals `newText` (caller should skip the RPC).
-     *  - Full-range replace when there is no shadow (first sync or post-{@link invalidate}).
-     *  - Line-level diff otherwise. Before returning, we locally reconstruct `newText` by applying
-     *    the diff to `old`; if that doesn't match, we fall back to a full-range replace and notify
-     *    the fallback callback. This catches any algorithmic regression in {@link diffToEdits}
-     *    without risking client corruption.
-     */
-    computeEdits(uri: string, newText: string): TextEdit[];
-}
-/**
- * Convert a {@link diffLines} result to a list of LSP {@link TextEdit}s keyed on line positions
- * in the *old* text. Contiguous added/removed hunks are coalesced into a single replace so the
- * client sees one edit per changed region.
- */
-export declare function diffToEdits(oldText: string, newText: string): TextEdit[];
-//# sourceMappingURL=language-client-text-shadow.d.ts.map

package/lib/documents/language-client-text-shadow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"language-client-text-shadow.d.ts","sourceRoot":"","sources":["../../src/documents/language-client-text-shadow.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EAAS,KAAK,QAAQ,EAAY,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IAClC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CAAC;CAC1F;AAKD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAMjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,wBAAwB;IAe/B,SAAS,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;IAC3D,SAAS,CAAC,SAAS,EAAE,oBAAoB;IAf5C,SAAS,CAAC,MAAM,sBAA6B;IAE7C;;;;;;;;;;OAUG;gBAEU,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,EACjD,SAAS,EAAE,oBAAoB;IAG5C,4FAA4F;IAC5F,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpC;;;;;;;;;;OAUG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpC,oGAAoG;IACpG,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7B;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE;CAkBxD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CA+BxE"}