@hydranium/core 1.0.0-next.10

package/lib/testing/node/lsp-server-connection.d.ts

@@ -0,0 +1,232 @@
+/********************************************************************************
+ * 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 Harness } from '@hydranium/protocol/testing';
+import { type Connection } from 'vscode-languageserver/node';
+import { type ApplyWorkspaceEditParams, type ApplyWorkspaceEditResult, type CompletionList, type Diagnostic, type Hover, type InitializeParams, type InitializeResult, type Position, type ProtocolConnection, type PublishDiagnosticsParams, type SemanticTokens } from 'vscode-languageserver-protocol/node';
+/**
+ * Options for {@link LspServerConnection.nextDiagnostics}, and for the
+ * subprocess tier's identically-shaped method — one type, so the in-process and
+ * spawned harnesses cannot drift into two spellings of the same discipline.
+ */
+export interface NextDiagnosticsOptions {
+    /**
+     * Index into {@link LspServerConnection.diagnostics} to search from,
+     * inclusive. Read `diagnostics.length` BEFORE the triggering action and pass
+     * it here: an already-captured publish at or after that point resolves
+     * immediately, so the wait no longer has to be armed before the action and
+     * cannot be answered by a publish that predates it. Omitted ⇒ only publishes
+     * arriving after the call are considered.
+     */
+    readonly fromIndex?: number;
+    /** Reject after this long. Defaults to the harness's own publish timeout, which differs by tier. */
+    readonly timeoutMs?: number;
+}
+/**
+ * One captured server→client `workspace/applyEdit`, with the two fields an
+ * edit-egress assertion actually reads lifted out of the `WorkspaceEdit`.
+ *
+ * Both are DERIVED, so a test asserts on them instead of re-walking a
+ * `documentChanges`-or-`changes` union whose shape the framework's egress may
+ * choose freely (a full-range replace and a minimal diff produce different
+ * edit lists for the same push). {@link params} stays available for the cases
+ * that need the version, the label or the file-operation kinds.
+ */
+export interface AppliedEdit {
+    /** The request as it arrived, unmodified. */
+    readonly params: ApplyWorkspaceEditParams;
+    /**
+     * Every URI the edit addresses, `documentChanges` first then `changes` keys.
+     * A rename contributes both its old and its new URI. This is what
+     * {@link LspServerConnection.nextAppliedEdit} matches against, and asserting
+     * on it is how a test pins WHICH URI the egress chose — the question a
+     * symlinked or renamed document makes non-trivial.
+     */
+    readonly uris: readonly string[];
+    /**
+     * Every text edit's `newText`, concatenated in edit order. A minimal diff
+     * therefore yields only the changed fragments, NOT the resulting document —
+     * so assert `toContain` on a fragment the push must carry rather than
+     * equality against a whole file. Snippet edits contribute nothing, having no
+     * `newText`.
+     */
+    readonly text: string;
+}
+/** Options for {@link LspServerConnection.nextAppliedEdit}. */
+export interface NextAppliedEditOptions {
+    /**
+     * Index into {@link LspServerConnection.appliedEdits} to search from,
+     * inclusive — the same contract as {@link NextDiagnosticsOptions.fromIndex},
+     * and needed for the same reason: one write can fan out to several pushes.
+     */
+    readonly fromIndex?: number;
+    /** Reject after this long. Defaults to the in-process publish timeout. */
+    readonly timeoutMs?: number;
+    /**
+     * Additional predicate the edit must satisfy. The framework coalesces
+     * pushes per URI and skips ones that diff to nothing, so a URI match alone
+     * can resolve on a sync that carries none of the text under test; narrow
+     * with e.g. `edit => edit.text.includes('…')`.
+     */
+    readonly match?: (edit: AppliedEdit) => boolean;
+}
+/**
+ * The in-process LSP transport seam — a real `Connection` over the in-memory
+ * {@link makeDuplexStreamPair}, plus the client side, the diagnostics capture,
+ * and the typed request facades — with NO services attached. It is the lower
+ * half of `makeLspHarness`, factored out so a caller can OWN the services
+ * tree: build the tree around {@link serverConnection} (`createXxxServices({
+ * connection })`) and attach the LSP head (`startLanguageServer(shared)`),
+ * exactly as a real server entrypoint does. That inversion — the connection is
+ * an input to the one tree, every head attaches to `shared` — is what lets
+ * multiple protocol heads share a single tree.
+ *
+ * `serverConnection` is the **seam handed to the caller** (it builds services
+ * onto it); `client` is the raw client seam + escape hatch for unwrapped
+ * requests; `diagnostics` is the append-only capture of every
+ * `publishDiagnostics` notification in arrival order; the lifecycle/sync/feature
+ * members are thin facades over `client` reusing `vscode-languageserver-protocol`
+ * types. Satisfies the uniform {@link Harness} contract.
+ */
+export interface LspServerConnection extends Harness {
+    /**
+     * Seam: the server-side `Connection`, NOT yet attached to a server. The caller
+     * composes the services tree onto it (`createXxxServices({ connection })`) and
+     * calls `startLanguageServer(services.shared)`, which wires the LSP handlers
+     * and calls `connection.listen()`.
+     */
+    readonly serverConnection: Connection;
+    /** Seam: the raw client connection over the in-memory wire; escape hatch for unwrapped requests. */
+    readonly client: ProtocolConnection;
+    /**
+     * Capture: every `publishDiagnostics` notification, in arrival order;
+     * append-only, never cleared. Stays live for the connection's whole lifetime,
+     * including while {@link nextDiagnostics} waits are armed.
+     *
+     * The right tool for a fan-out: record `diagnostics.length` before acting,
+     * then read the tail. Note the workspace init does NOT validate, so this is
+     * empty after `initialize` — a baseline has to be provoked by an edit or an
+     * explicit validating read.
+     */
+    readonly diagnostics: ReadonlyArray<PublishDiagnosticsParams>;
+    /**
+     * Capture: every server→client `workspace/applyEdit`, in arrival order;
+     * append-only, never cleared. The sibling of {@link diagnostics} for the
+     * EGRESS direction — `applyEditToLanguageClient` is a framework path that
+     * every adopter whose non-LSP client edits an open file goes through, and
+     * without this capture the request is unobservable and unanswered.
+     *
+     * Read as a fan-out, exactly like `diagnostics`: record `appliedEdits.length`
+     * before acting, then read the tail. One write can produce several pushes
+     * (one per language-client URI a document is open under) and their order is
+     * not the caller's to control.
+     *
+     * **The wire is answered `{ applied: true }` by default**, which is what a
+     * real language client does; {@link setApplyEditHandler} changes that, and
+     * without a handler registered at all the server's request would fail as an
+     * unhandled method.
+     */
+    readonly appliedEdits: ReadonlyArray<AppliedEdit>;
+    /**
+     * Drive the real LSP `initialize` → `initialized` handshake and return the
+     * `InitializeResult`. Defaults to no workspace folders (no async
+     * discovery/build, nothing racy to await); pass `workspaceFolders` for the
+     * fully faithful path. Required before any other request.
+     */
+    initialize(params?: Partial<InitializeParams>): Promise<InitializeResult>;
+    /**
+     * Drive the graceful `shutdown` request and await its response. The `exit`
+     * notification is intentionally NOT sent in-process: there is no server
+     * process to terminate, and `dispose()` owns teardown.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Send `textDocument/didOpen` for `uri` with full `text`. `languageId` is
+     * required — an empty/unregistered id yields a document the server never
+     * associates with a language (silent no-diagnostics). `version` defaults to 1.
+     */
+    openDocument(uri: string, text: string, languageId: string, version?: number): void;
+    /** Send `textDocument/didChange` for `uri` as a single full-text replacement at `version`. */
+    changeDocument(uri: string, text: string, version: number): void;
+    /**
+     * Request completion at `position`, normalized to a `CompletionList`
+     * (`CompletionItem[]`/`null` collapse to one). `item.textEdit` keeps its
+     * `InsertReplaceEdit | TextEdit` union.
+     */
+    completion(uri: string, position: Position): Promise<CompletionList>;
+    /** Request hover at `position`. */
+    hover(uri: string, position: Position): Promise<Hover | null>;
+    /** Request full-document semantic tokens for `uri`. */
+    semanticTokens(uri: string): Promise<SemanticTokens | null>;
+    /**
+     * Resolve with the diagnostics of the next `publishDiagnostics` matching
+     * `uri`. Reject on timeout so a missing publish fails fast instead of hanging.
+     * Register the returned promise BEFORE the triggering `openDocument`/
+     * `changeDocument`.
+     *
+     * Composes freely with {@link diagnostics} and with other waiters — all of
+     * them are served from one subscription, so arming a wait does not switch the
+     * capture off.
+     *
+     * **Pass `{ fromIndex }` when a single action fans out to SEVERAL
+     * documents**, as a cross-document rebuild does: without it this method
+     * answers "the next publish for one URI", which is the wrong question when
+     * the order of a cascade's publishes is not under the test's control, and it
+     * also has to be armed before the action. Record `diagnostics.length` first
+     * and hand it over; {@link diagnostics} remains available for a test that
+     * wants the whole tail rather than one URI's entry in it.
+     */
+    nextDiagnostics(uri: string, timeoutMsOrOptions?: number | NextDiagnosticsOptions): Promise<Diagnostic[]>;
+    /**
+     * Resolve with the next captured `workspace/applyEdit` that addresses `uri`
+     * (and satisfies {@link NextAppliedEditOptions.match}, when given). Reject on
+     * timeout so a missing push fails fast instead of hanging.
+     *
+     * The egress mirror of {@link nextDiagnostics}, with the same
+     * `fromIndex` discipline and the same composition guarantee: every waiter is
+     * served from one request handler, so arming a wait does not switch the
+     * {@link appliedEdits} capture off.
+     *
+     * **An egress push is asynchronous well past the call that triggers it** —
+     * the framework coalesces per URI and drives the sync from a build-phase
+     * settle, so a `ModelService.update` resolves long before the push is sent.
+     * Record `appliedEdits.length`, drive the edit, then await this; reading the
+     * capture on the line after the write proves nothing.
+     */
+    nextAppliedEdit(uri: string, timeoutMsOrOptions?: number | NextAppliedEditOptions): Promise<AppliedEdit>;
+    /**
+     * Decide what the client answers `workspace/applyEdit` with, so a test can
+     * drive the framework's rejection path — `applied: false` invalidates the
+     * text shadow and makes the retry a full-range replace, which is otherwise
+     * unreachable over a real wire. The capture is unaffected: the edit is
+     * recorded before the handler runs.
+     *
+     * Throwing from the handler surfaces to the server as an RPC failure, which
+     * is the other branch (`applyEditToLanguageClient` invalidates and rethrows).
+     */
+    setApplyEditHandler(handler: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult): void;
+    /**
+     * Release every resource: the diagnostics and applyEdit subscriptions, the
+     * client + server connections, the underlying stream pair. Idempotent. Does
+     * NOT send `shutdown`/`exit` — that is the explicit {@link shutdown} method.
+     */
+    dispose(): void;
+}
+/**
+ * Build the in-process LSP transport seam (server `Connection` + client + wire +
+ * diagnostics capture + typed facades) WITHOUT attaching a server. The caller
+ * composes a services tree onto {@link LspServerConnection.serverConnection} and
+ * calls `startLanguageServer`, then drives requests through the facades.
+ *
+ * `makeLspHarness` is the all-in-one convenience built on this primitive
+ * (it owns the `createServices` callback + `startLanguageServer` + `buildWorkspace`);
+ * use this primitive directly when the CALLER must own the tree — e.g. to attach
+ * additional protocol heads (data-server, GLSP) onto the same `shared` services.
+ */
+export declare function makeLspServerConnection(): LspServerConnection;
+//# sourceMappingURL=lsp-server-connection.d.ts.map

package/lib/testing/node/lsp-server-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-server-connection.d.ts","sourceRoot":"","sources":["../../../src/testing/node/lsp-server-connection.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAG3D,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,4BAA4B,CAAC;AAgB/E,OAAO,EAYJ,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EAErB,MAAM,qCAAqC,CAAC;AAc7C;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,sBAAsB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC;CAClD;AAsCD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,UAAU,CAAC;IACtC,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC;IAC9D;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAElD;;;;;OAKG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC1E;;;;OAIG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpF,8FAA8F;IAC9F,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEjE;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACrE,mCAAmC;IACnC,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAC9D,uDAAuD;IACvD,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAE5D;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,sBAAsB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAE1G;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,sBAAsB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEzG;;;;;;;;;OASG;IACH,mBAAmB,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,wBAAwB,KAAK,wBAAwB,GAAG,IAAI,CAAC;IAEnG;;;;OAIG;IACH,OAAO,IAAI,IAAI,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,IAAI,mBAAmB,CAkP7D"}

package/lib/testing/node/lsp-server-connection.js

@@ -0,0 +1,304 @@
+/********************************************************************************
+ * 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 { makeDuplexStreamPair } from '@hydranium/protocol/testing/node';
+import { StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node';
+import { ProposedFeatures } from 'vscode-languageserver/node';
+// The node `createConnection` from `vscode-languageserver/node` is built for a
+// standalone server PROCESS: it wires `process.exit()` onto the input stream's
+// `end`/`close` events, onto the `exit` notification (via its watchDog), and onto
+// a parent-pid liveness timer, and it calls `endProtocolConnection()` (a write)
+// on stream close. In-process every one of those is fatal — destroying the
+// streams at teardown trips the `close` handler, which writes into the destroyed
+// stream (an uncatchable synchronous `ERR_STREAM_DESTROYED`) and/or exits the host
+// test runner. The lower-level common `createConnection(connectionFactory,
+// watchDog, features)` form does none of that: it lets us inject a no-op-`exit`
+// WatchDog and build the connection over the in-memory streams, so teardown is the
+// primitive's responsibility alone.
+// (Both live on the package root, which re-exports the common server module —
+// the `lib/common/server.js` deep path is unreachable under the exports-only
+// package map the LSP 3.18 libs ship.)
+import { createConnection } from 'vscode-languageserver';
+import { ApplyWorkspaceEditRequest, CompletionRequest, DidChangeTextDocumentNotification, DidOpenTextDocumentNotification, HoverRequest, InitializeRequest, InitializedNotification, PublishDiagnosticsNotification, SemanticTokensRequest, ShutdownRequest, createProtocolConnection } from 'vscode-languageserver-protocol/node';
+/**
+ * Default wait for {@link LspServerConnection.nextDiagnostics}. Deliberately
+ * much shorter than the subprocess smoke's: in-process there is no spawn and no
+ * I/O, so a missing publish indicates a real wiring fault rather than slow
+ * startup, and the wait only has to clear an in-memory build while still failing
+ * fast instead of hanging the suite.
+ */
+const DEFAULT_DIAGNOSTICS_TIMEOUT_MS = 5_000;
+/** Default `version` assigned to {@link LspServerConnection.openDocument} when none is supplied. */
+const INITIAL_DOCUMENT_VERSION = 1;
+/** Every URI a {@link WorkspaceEdit} addresses, in `documentChanges` then `changes` order. */
+function editedUris(edit) {
+    const uris = [];
+    for (const change of edit.documentChanges ?? []) {
+        if ('textDocument' in change) {
+            uris.push(change.textDocument.uri);
+        }
+        else if ('oldUri' in change) {
+            uris.push(change.oldUri, change.newUri);
+        }
+        else {
+            uris.push(change.uri);
+        }
+    }
+    uris.push(...Object.keys(edit.changes ?? {}));
+    return uris;
+}
+/** Every text edit's `newText` in a {@link WorkspaceEdit}, concatenated in edit order. */
+function insertedText(edit) {
+    const parts = [];
+    for (const change of edit.documentChanges ?? []) {
+        if ('edits' in change) {
+            for (const textEdit of change.edits) {
+                if ('newText' in textEdit) {
+                    parts.push(textEdit.newText);
+                }
+            }
+        }
+    }
+    for (const textEdits of Object.values(edit.changes ?? {})) {
+        for (const textEdit of textEdits) {
+            parts.push(textEdit.newText);
+        }
+    }
+    return parts.join('');
+}
+/**
+ * Build the in-process LSP transport seam (server `Connection` + client + wire +
+ * diagnostics capture + typed facades) WITHOUT attaching a server. The caller
+ * composes a services tree onto {@link LspServerConnection.serverConnection} and
+ * calls `startLanguageServer`, then drives requests through the facades.
+ *
+ * `makeLspHarness` is the all-in-one convenience built on this primitive
+ * (it owns the `createServices` callback + `startLanguageServer` + `buildWorkspace`);
+ * use this primitive directly when the CALLER must own the tree — e.g. to attach
+ * additional protocol heads (data-server, GLSP) onto the same `shared` services.
+ */
+export function makeLspServerConnection() {
+    const pair = makeDuplexStreamPair();
+    // No-op watchDog: in-process, no LSP lifecycle event (parent-pid liveness, the
+    // `exit` notification, …) may exit the host test runner — `dispose()` owns
+    // teardown. See the import note on why the node `createConnection` is unusable.
+    const watchDog = {
+        shutdownReceived: false,
+        initialize: () => undefined,
+        exit: () => undefined
+    };
+    // Server side reads what the client wrote (clientToServer) and writes what the
+    // client reads (serverToClient), over a ProtocolConnection on the in-memory pair.
+    const serverConnection = createConnection(logger => createProtocolConnection(new StreamMessageReader(pair.clientToServer), new StreamMessageWriter(pair.serverToClient), logger), watchDog, ProposedFeatures.all);
+    // Client side mirrors the directions: reads serverToClient, writes clientToServer.
+    const client = createProtocolConnection(new StreamMessageReader(pair.serverToClient), new StreamMessageWriter(pair.clientToServer));
+    client.listen();
+    const diagnostics = [];
+    /**
+     * Waiters armed by {@link LspServerConnection.nextDiagnostics}, fanned out to
+     * from the ONE handler below.
+     *
+     * **There must be exactly one `onNotification` per method.** `vscode-jsonrpc`
+     * keeps a single handler per notification type, so a second registration
+     * silently DISPLACES the first — and disposing that second one then leaves no
+     * handler at all. Giving the capture and the per-URI waiters separate
+     * subscriptions therefore makes arming a wait switch the always-on capture
+     * off, and `diagnostics` reads empty in any suite that also awaits a publish
+     * — which is every suite that drives an edit.
+     */
+    const diagnosticsWaiters = [];
+    const diagnosticsSubscription = client.onNotification(PublishDiagnosticsNotification.type, params => {
+        diagnostics.push(params);
+        // Iterate a copy: a resolving waiter removes itself from the live array.
+        for (const waiter of [...diagnosticsWaiters]) {
+            if (waiter(params)) {
+                const at = diagnosticsWaiters.indexOf(waiter);
+                if (at >= 0) {
+                    diagnosticsWaiters.splice(at, 1);
+                }
+            }
+        }
+    });
+    const appliedEdits = [];
+    /**
+     * Waiters armed by {@link LspServerConnection.nextAppliedEdit}, fanned out to
+     * from the ONE handler below — `vscode-jsonrpc` keeps a single handler per
+     * REQUEST type just as it does per notification type, so a second
+     * `onRequest` would displace this one and leave the server's `applyEdit`
+     * unanswered.
+     */
+    const appliedEditWaiters = [];
+    let applyEditHandler = () => ({ applied: true });
+    const appliedEditSubscription = client.onRequest(ApplyWorkspaceEditRequest.type, (params) => {
+        const edit = { params, uris: editedUris(params.edit), text: insertedText(params.edit) };
+        // Record BEFORE the handler runs, so a handler that rejects the edit or
+        // throws still leaves the push observable — the send is what the egress
+        // assertion is about.
+        appliedEdits.push(edit);
+        for (const waiter of [...appliedEditWaiters]) {
+            if (waiter(edit)) {
+                const at = appliedEditWaiters.indexOf(waiter);
+                if (at >= 0) {
+                    appliedEditWaiters.splice(at, 1);
+                }
+            }
+        }
+        return applyEditHandler(params);
+    });
+    let disposed = false;
+    return {
+        serverConnection,
+        client,
+        diagnostics,
+        appliedEdits,
+        async initialize(params) {
+            const initializeParams = {
+                processId: process.pid,
+                rootUri: null,
+                workspaceFolders: null,
+                capabilities: {},
+                ...params
+            };
+            const result = await client.sendRequest(InitializeRequest.type, initializeParams);
+            // Await the notification send so its write fully drains before
+            // `initialize()` resolves. `sendNotification` is fire-and-forget at the
+            // protocol level but returns a Promise that settles when the bytes hit
+            // the stream; without the await, a test that disposes shortly after
+            // `initialize()` (with no intervening awaited request) would destroy the
+            // streams mid-write — a write-after-destroy rejection.
+            await client.sendNotification(InitializedNotification.type, {});
+            return result;
+        },
+        async shutdown() {
+            // No `exit` NOTIFICATION: in-process its only effect would be the no-op
+            // watchDog, and being fire-and-forget it would still be draining when
+            // `dispose()` destroys the streams — racing teardown into a
+            // write-after-destroy. The subprocess smoke covers the real
+            // `exit`/process-exit path.
+            await client.sendRequest(ShutdownRequest.type, undefined);
+        },
+        openDocument(uri, text, languageId, version) {
+            client.sendNotification(DidOpenTextDocumentNotification.type, {
+                textDocument: {
+                    uri,
+                    languageId,
+                    version: version ?? INITIAL_DOCUMENT_VERSION,
+                    text
+                }
+            });
+        },
+        changeDocument(uri, text, version) {
+            client.sendNotification(DidChangeTextDocumentNotification.type, {
+                textDocument: { uri, version },
+                contentChanges: [{ text }]
+            });
+        },
+        async completion(uri, position) {
+            const response = await client.sendRequest(CompletionRequest.type, {
+                textDocument: { uri },
+                position
+            });
+            if (response === null) {
+                return { isIncomplete: false, items: [] };
+            }
+            if (Array.isArray(response)) {
+                return { isIncomplete: false, items: response };
+            }
+            return response;
+        },
+        hover(uri, position) {
+            return client.sendRequest(HoverRequest.type, { textDocument: { uri }, position });
+        },
+        semanticTokens(uri) {
+            return client.sendRequest(SemanticTokensRequest.type, { textDocument: { uri } });
+        },
+        nextDiagnostics(uri, timeoutMsOrOptions) {
+            const options = typeof timeoutMsOrOptions === 'number' ? { timeoutMs: timeoutMsOrOptions } : (timeoutMsOrOptions ?? {});
+            const timeoutMs = options.timeoutMs ?? DEFAULT_DIAGNOSTICS_TIMEOUT_MS;
+            const { fromIndex } = options;
+            if (fromIndex !== undefined) {
+                // Replay from the capture first: the publish this call is asking
+                // about may already have arrived, and a waiter can only ever see
+                // publishes that come later.
+                const captured = diagnostics.slice(Math.max(0, fromIndex)).find(params => params.uri === uri);
+                if (captured) {
+                    return Promise.resolve(captured.diagnostics);
+                }
+            }
+            // A waiter on the ONE subscription above, never a second
+            // `onNotification` — see `diagnosticsWaiters` for why that matters.
+            // Without `fromIndex`, already-captured publishes are NOT replayed.
+            return new Promise((resolve, reject) => {
+                const waiter = (params) => {
+                    if (params.uri !== uri) {
+                        return false;
+                    }
+                    clearTimeout(timer);
+                    resolve(params.diagnostics);
+                    return true;
+                };
+                const timer = setTimeout(() => {
+                    const at = diagnosticsWaiters.indexOf(waiter);
+                    if (at >= 0) {
+                        diagnosticsWaiters.splice(at, 1);
+                    }
+                    reject(new Error(`Timed out waiting for diagnostics for ${uri}`));
+                }, timeoutMs);
+                diagnosticsWaiters.push(waiter);
+            });
+        },
+        nextAppliedEdit(uri, timeoutMsOrOptions) {
+            const options = typeof timeoutMsOrOptions === 'number' ? { timeoutMs: timeoutMsOrOptions } : (timeoutMsOrOptions ?? {});
+            const timeoutMs = options.timeoutMs ?? DEFAULT_DIAGNOSTICS_TIMEOUT_MS;
+            const { fromIndex, match } = options;
+            const matches = (edit) => edit.uris.includes(uri) && (match?.(edit) ?? true);
+            if (fromIndex !== undefined) {
+                // Replay from the capture first, for the same reason
+                // `nextDiagnostics` does: the push may already have arrived, and a
+                // waiter only ever sees later ones.
+                const captured = appliedEdits.slice(Math.max(0, fromIndex)).find(matches);
+                if (captured) {
+                    return Promise.resolve(captured);
+                }
+            }
+            return new Promise((resolve, reject) => {
+                const waiter = (edit) => {
+                    if (!matches(edit)) {
+                        return false;
+                    }
+                    clearTimeout(timer);
+                    resolve(edit);
+                    return true;
+                };
+                const timer = setTimeout(() => {
+                    const at = appliedEditWaiters.indexOf(waiter);
+                    if (at >= 0) {
+                        appliedEditWaiters.splice(at, 1);
+                    }
+                    reject(new Error(`Timed out waiting for a workspace/applyEdit addressing ${uri}`));
+                }, timeoutMs);
+                appliedEditWaiters.push(waiter);
+            });
+        },
+        setApplyEditHandler(handler) {
+            applyEditHandler = handler;
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            appliedEditSubscription.dispose();
+            diagnosticsSubscription.dispose();
+            client.dispose();
+            serverConnection.dispose();
+            pair.dispose();
+        }
+    };
+}
+//# sourceMappingURL=lsp-server-connection.js.map

package/lib/testing/node/lsp-server-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-server-connection.js","sourceRoot":"","sources":["../../../src/testing/node/lsp-server-connection.ts"],"names":[],"mappings":"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"}

package/lib/testing/node/scratch-workspace.d.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+/** Options for {@link makeScratchWorkspace}. */
+export interface ScratchWorkspaceOptions {
+    /**
+     * Directory to copy in as the starting content, recursively. Omit for an
+     * empty workspace.
+     */
+    readonly seed?: string;
+    /**
+     * Prefix for the temp directory name, so a leaked directory is traceable to
+     * the suite that made it. Defaults to `hydranium-scratch-`.
+     */
+    readonly prefix?: string;
+}
+/** A temp directory with a cleanup hook. */
+export interface ScratchWorkspace {
+    /** Absolute path of the workspace root. */
+    readonly root: string;
+    /**
+     * Write a file under {@link root}, creating parent directories. Returns the
+     * absolute path, so a caller can hand it straight to a URI.
+     */
+    write(relativePath: string, content: string): string;
+    /** Absolute path of `relativePath` under {@link root}, without writing. */
+    resolve(relativePath: string): string;
+    /**
+     * `file:` URI string of `relativePath` under {@link root}, or of the root
+     * itself when called with no argument. This is what the wire carries, so it
+     * is what a test hands to `initialize`, `openModelDocument` or any request
+     * keyed by URI.
+     *
+     * **Exists so `` `file://${workspace.root}` `` cannot be hand-rolled**, which
+     * is not a style preference. {@link root} comes from `mkdtempSync` and is
+     * therefore OS-NATIVE: on Windows the template form yields
+     * `file://C:\dir\…`, where the drive letter parses as the authority and the
+     * backslashes are not separators, so every URI comparison in the suite fails
+     * against the `file:///c:/dir/…` the server produces. `URI.file` applies
+     * the drive-letter lowercasing, the third slash and the percent-encoding that
+     * makes the two agree.
+     */
+    uri(relativePath?: string): string;
+    /**
+     * Remove the directory. Idempotent, and safe to call from an `afterEach`
+     * that may run after a failed `beforeEach`.
+     */
+    dispose(): void;
+}
+/**
+ * Create a throwaway workspace directory. The caller owns teardown — pair the
+ * returned {@link ScratchWorkspace.dispose} with an `afterEach`.
+ */
+export declare function makeScratchWorkspace(options?: ScratchWorkspaceOptions): ScratchWorkspace;
+//# sourceMappingURL=scratch-workspace.d.ts.map

package/lib/testing/node/scratch-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-workspace.d.ts","sourceRoot":"","sources":["../../../src/testing/node/scratch-workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAgDlF,gDAAgD;AAChD,MAAM,WAAW,uBAAuB;IACrC;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,4CAA4C;AAC5C,MAAM,WAAW,gBAAgB;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACrD,2EAA2E;IAC3E,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,uBAA4B,GAAG,gBAAgB,CA6B5F"}