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

package/src/testing/make-test-services.ts

@@ -10,6 +10,7 @@
 import {
    type Clock,
    DefaultTracer,
+   type Locale,
    type Logger,
    NoopLogger,
    type Project,
@@ -18,15 +19,25 @@ import {
    type TransferDiagnostic,
    type TransferElement
 } from '@hydranium/protocol';
-import { ServerLocale } from '../locale/server-locale.js';
-import { ServerMessageRenderer } from '../messages/renderer.js';
+import { DefaultServerLocale, type ServerLocale } from '../locale/server-locale.js';
+import { DefaultMessageRenderer, type MessageRenderer } from '../messages/renderer.js';
 import type { Harness } from '@hydranium/protocol/testing';
 import { type AstNode, type AstNodeDescription, type WorkspaceLock } from '@hydranium/langium';
+import {
+   type ClientSessionFactory,
+   type ClientSessionFactoryOptions,
+   DefaultClientSessionFactory
+} from '../langium/model-service/client-session.js';
 import type { ModelService, ModelServiceOptions } from '../langium/model-service/model-service.js';
 import type { ServerSharedServices } from '../langium/module.js';
-import { TransferEncoder } from '../langium/transfer/transfer-encoder.js';
+import type { AstDiagnostic } from '../langium/validation/document-validator.js';
+import { DefaultTransferEncoder, type TransferEncoder } from '../langium/transfer/transfer-encoder.js';
 import { DefaultDocumentUriPolicy, type DocumentUriPolicy } from '../langium/workspace/document-uri-policy.js';
 import { HydraniumWorkspaceLock } from '../langium/workspace/hydranium-workspace-lock.js';
+import { DefaultFileSystemTaskQueue, type FileSystemTaskQueue } from '../documents/file-system-task-queue.js';
+import { DefaultModelLedger, type ModelLedger } from '../documents/model-ledger.js';
+import { DefaultDocumentReleaseHandler, type DocumentReleaseHandler } from '../documents/document-release-handler.js';
+import { DefaultVersionSyncService, type VersionSyncService } from '../documents/version-sync-service.js';
 import type { FakeDocumentOptions } from './fake-document.js';
 import { makeStubDocumentBuilder, type StubDocumentBuilder } from './stub-document-builder.js';
 import { makeStubIndexManager, type StubIndexManager } from './stub-index-manager.js';
@@ -48,12 +59,21 @@ import { makeStubWritableFileSystem, type StubWritableFileSystem } from './stub-
  * to `ServerSharedServices` in {@link makeTestServices} is therefore the
  * single named place where the "stub stands in for the full service tree"
  * assertion happens.
+ *
+ * **`TDiagnostic` and `TTransferDiagnostic` are the two ends of a conversion
+ * and must stay separate.** The first is what the build left on
+ * `LangiumDocument.diagnostics` and what `ModelService` hands back on an
+ * `AstDocument`; the second is what `TransferEncoder.toTransferDiagnostic`
+ * produces for the wire. One parameter serving both makes the tree
+ * unbindable for an adopter who extends either shape, since extending one
+ * says nothing about the other.
  */
 export interface TestSharedServices<
    TAst extends AstNode = AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TTransferDiagnostic extends TransferDiagnostic = TransferDiagnostic
 > {
    readonly Clock: Clock;
    readonly Logger: Logger;
@@ -74,6 +94,8 @@ export interface TestSharedServices<
       SelfSaveRegistry: StubSelfSaveRegistry;
       ProjectManager: StubProjectManager<TProject>;
       DocumentUriPolicy: DocumentUriPolicy;
+      /** The REAL queue: a stub that runs each task at once hides the save interleaving the queue exists to prevent. */
+      FileSystemTaskQueue: FileSystemTaskQueue;
       /**
        * Present only when {@link MakeTestServicesOptions.seedIndex} was passed.
        * Omitted otherwise for the same reason as `ServiceRegistry` — see that
@@ -90,10 +112,17 @@ export interface TestSharedServices<
        * through this tree and let a reentrant write pass unnoticed.
        */
       WorkspaceLock: WorkspaceLock;
+      /** The REAL ledger: it is a weak map with no dependencies. */
+      ModelLedger: ModelLedger;
+      /** The REAL service, over this tree's stubs; it reconciles nothing against the stub store. */
+      VersionSyncService: VersionSyncService;
+      /** The REAL handler, over this tree's stubs; the stub store releases nothing to it. */
+      DocumentReleaseHandler: DocumentReleaseHandler;
    };
    readonly model: {
-      TransferEncoder: TransferEncoder<unknown, TDiagnostic>;
+      TransferEncoder: TransferEncoder<TTransferDiagnostic>;
       ModelService: ModelService<TAst, TDiagnostic, TTransfer>;
+      ClientSessionFactory: ClientSessionFactory;
    };
    /**
     * The REAL services, not stubs — the framework renderer's no-catalogue
@@ -103,15 +132,16 @@ export interface TestSharedServices<
     * `Validated` phase, where an omitted slot is a `TypeError`.
     */
    readonly ServerLocale: ServerLocale;
-   readonly MessageRenderer: ServerMessageRenderer;
+   readonly MessageRenderer: MessageRenderer;
 }
 
 /** Optional configuration for {@link makeTestServices}. */
 export interface MakeTestServicesOptions<
    TAst extends AstNode = AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TTransferDiagnostic extends TransferDiagnostic = TransferDiagnostic
 > {
    /**
     * Serialiser used by the bundled `StubModelService`. The stub tree
@@ -128,9 +158,9 @@ export interface MakeTestServicesOptions<
     * passes every sentence through unchanged. Supply one to install a catalogue
     * or to drive the throwing path.
     */
-   messageRenderer?: (services: ServerSharedServices<TProject>) => ServerMessageRenderer;
+   messageRenderer?: (services: ServerSharedServices<TProject>) => MessageRenderer;
    /** Locale handed to the bundle's {@link ServerLocale}. Default: none, i.e. the framework's English. */
-   locale?: string;
+   locale?: Locale;
    /**
     * Languages to register on a {@link StubServiceRegistry} bound on the
     * `ServiceRegistry` slot. This is how a test gets multi-language routing:
@@ -139,7 +169,7 @@ export interface MakeTestServicesOptions<
     *
     * **Default: no `ServiceRegistry` slot at all.** Binding an empty registry
     * by default would silently change behaviour for the tests that rely on the
-    * slot being absent — `ModelService.updateRewriteService` optional-chains it
+    * slot being absent — `DefaultModelService.rewriteModel` optional-chains it
     * precisely for those bundles — so a registry appears only when a test asks
     * for one.
     */
@@ -197,16 +227,23 @@ export interface MakeTestServicesOptions<
    modelService?: (services: ServerSharedServices<TProject>) => ModelService<TAst, TDiagnostic, TTransfer>;
    /**
     * Framework {@link ModelServiceOptions} for the DEFAULT stub service, so a
-    * test can reach an option-gated path (`serializeBuilds`, the slow-warn
-    * threshold) without supplying a whole {@link modelService} factory. Ignored
-    * when `modelService` is given — that factory owns its own construction.
+    * test can reach an option-gated path (`allowReentrantBuilds`) without supplying
+    * a whole {@link modelService} factory. Ignored when `modelService` is
+    * given — that factory owns its own construction.
     */
    modelServiceOptions?: ModelServiceOptions;
+   /**
+    * Options of the {@link DefaultClientSessionFactory} bound on
+    * `model.ClientSessionFactory`, so a test can reach the slow-update warn.
+    * Its sessions serialise and rebuild through the `model.ModelService` slot,
+    * so a test of a model service subclass passes it as {@link modelService}.
+    */
+   clientSessionFactoryOptions?: ClientSessionFactoryOptions;
    /**
     * Override the {@link TransferEncoder} factory. Default: framework
     * {@link TransferEncoder} with no overrides.
     */
-   transferEncoder?: (services: ServerSharedServices<TProject>) => TransferEncoder<unknown, TDiagnostic>;
+   transferEncoder?: (services: ServerSharedServices<TProject, TTransferDiagnostic>) => TransferEncoder<TTransferDiagnostic>;
 }
 
 /**
@@ -224,11 +261,12 @@ export interface MakeTestServicesOptions<
  */
 export interface TestServicesBundle<
    TAst extends AstNode = AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TTransferDiagnostic extends TransferDiagnostic = TransferDiagnostic
 > extends Harness {
-   readonly services: ServerSharedServices<TProject>;
+   readonly services: ServerSharedServices<TProject, TTransferDiagnostic>;
    readonly documents: StubLangiumDocuments<TAst, TDiagnostic>;
    readonly textDocuments: StubHydraniumTextDocuments;
    readonly astDocumentManager: StubAstDocumentManager<TAst, TDiagnostic>;
@@ -237,6 +275,7 @@ export interface TestServicesBundle<
    readonly selfSaveRegistry: StubSelfSaveRegistry;
    readonly projectManager: StubProjectManager<TProject>;
    readonly documentUriPolicy: DocumentUriPolicy;
+   readonly modelLedger: ModelLedger;
    /**
     * The registry bound on the `ServiceRegistry` slot, or `undefined` when no
     * {@link MakeTestServicesOptions.languages} were declared.
@@ -248,7 +287,7 @@ export interface TestServicesBundle<
     */
    readonly indexManager: StubIndexManager | undefined;
    readonly modelService: ModelService<TAst, TDiagnostic, TTransfer>;
-   readonly transferEncoder: TransferEncoder<unknown, TDiagnostic>;
+   readonly transferEncoder: TransferEncoder<TTransferDiagnostic>;
    readonly logger: Logger;
    /** The clock bound on the `Clock` slot — a `makeFakeClock()` if one was passed. */
    readonly clock: Clock;
@@ -259,7 +298,7 @@ export interface TestServicesBundle<
     */
    readonly serverLocale: ServerLocale;
    /** The renderer bound on `MessageRenderer` — the framework's own unless one was supplied. */
-   readonly messageRenderer: ServerMessageRenderer;
+   readonly messageRenderer: MessageRenderer;
 }
 
 /**
@@ -274,22 +313,25 @@ export interface TestServicesBundle<
  */
 export function makeTestServices<
    TAst extends AstNode = AstNode,
-   TDiagnostic extends TransferDiagnostic = TransferDiagnostic,
+   TDiagnostic extends AstDiagnostic = AstDiagnostic,
    TTransfer extends TransferElement = TransferElement,
-   TProject extends Project = Project
+   TProject extends Project = Project,
+   TTransferDiagnostic extends TransferDiagnostic = TransferDiagnostic
 >(
-   options: MakeTestServicesOptions<TAst, TDiagnostic, TTransfer, TProject> = {}
-): TestServicesBundle<TAst, TDiagnostic, TTransfer, TProject> {
+   options: MakeTestServicesOptions<TAst, TDiagnostic, TTransfer, TProject, TTransferDiagnostic> = {}
+): TestServicesBundle<TAst, TDiagnostic, TTransfer, TProject, TTransferDiagnostic> {
    const documents = makeStubLangiumDocuments<TAst, TDiagnostic>(options.seedDocuments);
    const textDocuments = makeStubHydraniumTextDocuments();
-   const documentBuilder = makeStubDocumentBuilder();
-   const selfSaveRegistry = makeStubSelfSaveRegistry();
-   const fileSystem = makeStubWritableFileSystem(selfSaveRegistry);
-   const projectManager = makeStubProjectManager<TProject>(options.seedProjects);
-   const astDocumentManager = makeStubAstDocumentManager<TAst, TDiagnostic>(textDocuments, fileSystem, documents);
    const logger = options.logger ?? new NoopLogger();
    const clock = options.clock ?? new SystemClock();
    const tracer = new DefaultTracer(logger, clock);
+   const workspaceLock = new HydraniumWorkspaceLock({ Clock: clock, Tracer: tracer });
+   const documentBuilder = makeStubDocumentBuilder(workspaceLock);
+   const selfSaveRegistry = makeStubSelfSaveRegistry();
+   const fileSystem = makeStubWritableFileSystem(selfSaveRegistry);
+   const projectManager = makeStubProjectManager<TProject>(options.seedProjects);
+   const modelLedger = new DefaultModelLedger();
+   const astDocumentManager = makeStubAstDocumentManager<TAst, TDiagnostic>(textDocuments, fileSystem, documents, modelLedger);
    const documentUriPolicy = options.documentUriPolicy ?? new DefaultDocumentUriPolicy();
    const serviceRegistry = options.languages
       ? makeStubServiceRegistry(options.languages, { openLanguageIds: options.openLanguageIds })
@@ -312,11 +354,11 @@ export function makeTestServices<
    // is dependency-free (as `HydraniumWorkspaceLock` is) — a no-op stub of a
    // synchronisation primitive hides the very interleaving it exists to prevent.
    //
-   // `model.TransferEncoder` / `model.ModelService` are populated below
+   // The `model` slots are populated below
    // (after the factories run); the literal uses unsafe casts to
    // partially-built objects to satisfy TestSharedServices, then patches
    // them in.
-   const services: TestSharedServices<TAst, TDiagnostic, TTransfer, TProject> = {
+   const services: TestSharedServices<TAst, TDiagnostic, TTransfer, TProject, TTransferDiagnostic> = {
       Clock: clock,
       Logger: logger,
       Tracer: tracer,
@@ -336,39 +378,48 @@ export function makeTestServices<
          // Spread for the same reason as `ServiceRegistry` above — the slot must
          // be genuinely ABSENT, not present-and-undefined, when no index was seeded.
          ...(indexManager ? { IndexManager: indexManager } : {}),
-         WorkspaceLock: new HydraniumWorkspaceLock()
+         WorkspaceLock: workspaceLock,
+         FileSystemTaskQueue: new DefaultFileSystemTaskQueue({ workspace: { DocumentUriPolicy: documentUriPolicy } }),
+         ModelLedger: modelLedger,
+         // Patched in below, as both read the tree they belong to.
+         VersionSyncService: {} as VersionSyncService,
+         DocumentReleaseHandler: {} as DocumentReleaseHandler
       },
-      model: {} as TestSharedServices<TAst, TDiagnostic, TTransfer, TProject>['model'],
+      model: {} as TestSharedServices<TAst, TDiagnostic, TTransfer, TProject, TTransferDiagnostic>['model'],
       ServerLocale: {} as ServerLocale,
-      MessageRenderer: {} as ServerMessageRenderer
+      MessageRenderer: {} as DefaultMessageRenderer
    };
-   const sharedServices = services as unknown as ServerSharedServices<TProject>;
+   const sharedServices = services as unknown as ServerSharedServices<TProject, TTransferDiagnostic>;
 
    // Patched in after the literal, like `model` below: both read the tree they
    // belong to, and the renderer reads the locale service.
-   const mutableMessages = services as { ServerLocale: ServerLocale; MessageRenderer: ServerMessageRenderer };
-   const serverLocale = new ServerLocale(sharedServices);
+   services.workspace.VersionSyncService = new DefaultVersionSyncService(sharedServices);
+   services.workspace.DocumentReleaseHandler = new DefaultDocumentReleaseHandler(sharedServices);
+   const mutableMessages = services as { ServerLocale: ServerLocale; MessageRenderer: MessageRenderer };
+   const serverLocale = new DefaultServerLocale(sharedServices);
    if (options.locale) {
       serverLocale.accept(options.locale);
    }
    mutableMessages.ServerLocale = serverLocale;
-   const messageRenderer = options.messageRenderer?.(sharedServices) ?? new ServerMessageRenderer(sharedServices);
+   const messageRenderer = options.messageRenderer?.(sharedServices) ?? new DefaultMessageRenderer(sharedServices);
    mutableMessages.MessageRenderer = messageRenderer;
 
    const serialize = options.serialize ?? ((_uri: string, root: TTransfer) => JSON.stringify(root));
    const transferEncoder = options.transferEncoder
       ? options.transferEncoder(sharedServices)
-      : new TransferEncoder<unknown, TDiagnostic>(sharedServices);
+      : new DefaultTransferEncoder<unknown, TTransferDiagnostic>(sharedServices);
    const modelService = options.modelService
       ? options.modelService(sharedServices)
       : makeStubModelService<TAst, TDiagnostic, TTransfer>(sharedServices, serialize, options.modelServiceOptions);
 
    const mutableModel = services.model as {
-      TransferEncoder: TransferEncoder<unknown, TDiagnostic>;
+      TransferEncoder: TransferEncoder<TTransferDiagnostic>;
       ModelService: ModelService<TAst, TDiagnostic, TTransfer>;
+      ClientSessionFactory: ClientSessionFactory;
    };
    mutableModel.TransferEncoder = transferEncoder;
    mutableModel.ModelService = modelService;
+   mutableModel.ClientSessionFactory = new DefaultClientSessionFactory(sharedServices, options.clientSessionFactoryOptions);
 
    return {
       services: sharedServices,
@@ -380,6 +431,7 @@ export function makeTestServices<
       selfSaveRegistry,
       projectManager,
       documentUriPolicy,
+      modelLedger,
       serviceRegistry,
       indexManager,
       modelService,

package/src/testing/make-test-tracer.ts

@@ -71,6 +71,32 @@ export function makeCapturingLogger(): CapturingLogger {
    return { logger: new Capturing(), lines };
 }
 
+/** A captured line with the logger component it was emitted under. */
+export interface AttributedLine extends CapturedLine {
+   readonly component: string | undefined;
+}
+
+/** A {@link Logger} whose emitted lines are captured with their component. */
+export interface AttributingLogger {
+   readonly logger: Logger;
+   /** Every line emitted through the logger (and its derived children), in order. */
+   readonly lines: AttributedLine[];
+}
+
+/** A capturing logger that also records each line's component, which {@link makeCapturingLogger} drops. */
+export function makeAttributingLogger(): AttributingLogger {
+   const lines: AttributedLine[] = [];
+   class Attributing extends NoopLogger {
+      protected override emit(level: LogLevel, _label: string, message: string): void {
+         lines.push({ level, message, component: this.component });
+      }
+      protected override derive(component: string): this {
+         return new Attributing(component) as this;
+      }
+   }
+   return { logger: new Attributing(), lines };
+}
+
 /** A {@link Tracer} whose emitted lines are captured for assertions. */
 export interface CapturingTracer {
    readonly tracer: Tracer;

package/src/testing/node/applied-edit-capture.ts

@@ -0,0 +1,141 @@
+/********************************************************************************
+ * 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 {
+   ApplyWorkspaceEditRequest,
+   type ApplyWorkspaceEditParams,
+   type ApplyWorkspaceEditResult,
+   type ProtocolConnection,
+   type WorkspaceEdit
+} from 'vscode-languageserver-protocol/node';
+import type { AppliedEdit, NextAppliedEditOptions } from './lsp-server-connection.js';
+
+/**
+ * The client side of `workspace/applyEdit` on one LSP connection, shared by the
+ * in-process and the spawned tiers so their capture and wait cannot drift.
+ */
+export interface AppliedEditCapture {
+   readonly appliedEdits: ReadonlyArray<AppliedEdit>;
+   nextAppliedEdit(uri: string, timeoutMsOrOptions?: number | NextAppliedEditOptions): Promise<AppliedEdit>;
+   setApplyEditHandler(handler: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult>): void;
+   dispose(): void;
+}
+
+/**
+ * Answer and record every `workspace/applyEdit` arriving on `client`.
+ *
+ * Register before the connection can receive one: `vscode-jsonrpc` keeps a
+ * single handler per request type, so this must be the only `applyEdit`
+ * handler on `client`, and a second registration displaces the capture.
+ */
+export function captureAppliedEdits(client: ProtocolConnection, defaultTimeoutMs: number): AppliedEditCapture {
+   const appliedEdits: AppliedEdit[] = [];
+   const waiters: Array<(edit: AppliedEdit) => boolean> = [];
+   let handler: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult> = () => ({
+      applied: true
+   });
+   const subscription = client.onRequest(ApplyWorkspaceEditRequest.type, (params: ApplyWorkspaceEditParams) => {
+      const edit: AppliedEdit = { 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 [...waiters]) {
+         if (waiter(edit)) {
+            const at = waiters.indexOf(waiter);
+            if (at >= 0) {
+               waiters.splice(at, 1);
+            }
+         }
+      }
+      return handler(params);
+   });
+
+   return {
+      appliedEdits,
+
+      nextAppliedEdit(uri: string, timeoutMsOrOptions?: number | NextAppliedEditOptions): Promise<AppliedEdit> {
+         const options: NextAppliedEditOptions =
+            typeof timeoutMsOrOptions === 'number' ? { timeoutMs: timeoutMsOrOptions } : (timeoutMsOrOptions ?? {});
+         const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
+         const { fromIndex, match } = options;
+         const matches = (edit: AppliedEdit): boolean => edit.uris.includes(uri) && (match?.(edit) ?? true);
+         if (fromIndex !== undefined) {
+            // Replay from the capture first: 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<AppliedEdit>((resolve, reject) => {
+            const waiter = (edit: AppliedEdit): boolean => {
+               if (!matches(edit)) {
+                  return false;
+               }
+               clearTimeout(timer);
+               resolve(edit);
+               return true;
+            };
+            const timer = setTimeout(() => {
+               const at = waiters.indexOf(waiter);
+               if (at >= 0) {
+                  waiters.splice(at, 1);
+               }
+               reject(new Error(`Timed out waiting for a workspace/applyEdit addressing ${uri}`));
+            }, timeoutMs);
+            waiters.push(waiter);
+         });
+      },
+
+      setApplyEditHandler(next: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult>): void {
+         handler = next;
+      },
+
+      dispose(): void {
+         subscription.dispose();
+      }
+   };
+}
+
+/** Every URI a {@link WorkspaceEdit} addresses, in `documentChanges` then `changes` order. */
+function editedUris(edit: WorkspaceEdit): string[] {
+   const uris: string[] = [];
+   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: WorkspaceEdit): string {
+   const parts: string[] = [];
+   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('');
+}

package/src/testing/node/index.ts

@@ -27,3 +27,4 @@ export * from './lsp-harness.js';
 export * from './lsp-server-connection.js';
 export * from './scratch-workspace.js';
 export * from './spawned-server.js';
+export * from './unhandled-rejections.js';

package/src/testing/node/lsp-harness.ts

@@ -216,12 +216,14 @@ export function makeLspHarness(options: MakeLspHarnessOptions): LspHarness {
       },
       shutdown: transport.shutdown,
       openDocument: transport.openDocument,
+      closeDocument: transport.closeDocument,
       changeDocument: transport.changeDocument,
       completion: transport.completion,
       hover: transport.hover,
       semanticTokens: transport.semanticTokens,
       nextDiagnostics: transport.nextDiagnostics,
       appliedEdits: transport.appliedEdits,
+      wireBytes: transport.wireBytes,
       nextAppliedEdit: transport.nextAppliedEdit,
       setApplyEditHandler: transport.setApplyEditHandler,
       buildWorkspace: folders => buildWorkspaceProgrammatically(services, folders),