@hydranium/conformance 1.0.0-next.27 → 1.0.0-next.271

package/src/glsp/index.ts

@@ -12,7 +12,9 @@
  * head, generic over the adopter's action type `TAction`. The kit imports NO
  * `@eclipse-glsp/*` types: the FIXTURE supplies the native actions
  * (`requestModel()`, `createOperation.action()`) and the kit matches responses
- * by `kind` (a `string`) via the driver's `nextAction`.
+ * by `kind` (a `string`) via the driver's `nextAction`. The one field it reads
+ * beyond `kind` is the `reason` of the `setDirtyState` that is an operation's
+ * receipt.
  *
  * The driver port (`GlspConformanceDriver<TAction>`) is the minimal
  * `start` / `dispatch` / `nextAction` surface that `@hydranium/glsp-server/
@@ -26,6 +28,7 @@
 
 import assert from 'node:assert/strict';
 import type { Harness } from '@hydranium/protocol/testing';
+import { describeError } from '@hydranium/protocol';
 import type { ConformanceCheck } from '../conformance-suite.js';
 
 /**
@@ -40,7 +43,12 @@ export interface GlspConformanceDriver<TAction> extends Harness {
    start(): Promise<void>;
    /** Send an action to the server. Fire-and-forget (GLSP `process` is `void`). */
    dispatch(action: TAction): void;
-   /** Resolve with the next captured action whose `kind` matches; reject on timeout. */
+   /**
+    * Resolve with the next action whose `kind` matches and that arrived after
+    * the last {@link dispatch}, or since `start` before any; reject on timeout.
+    * Only after the dispatch, so an action an earlier step sent cannot pass for
+    * the answer to this one.
+    */
    nextAction<T extends TAction = TAction>(kind: string, timeoutMs?: number): Promise<T>;
 }
 
@@ -64,7 +72,18 @@ export interface GlspCreateOperationSpec<TAction, TDriver extends GlspConformanc
     *   loaded.
     */
    readonly action: (driver: TDriver) => TAction;
-   /** The action kind the server settles the operation with (e.g. a re-`RequestBounds` for client-laid-out diagrams). */
+   /**
+    * The action kind the server settles the operation with (e.g. a
+    * re-`RequestBounds` for client-laid-out diagrams).
+    *
+    * The kit also waits for the operation's receipt: GLSP's
+    * `OperationActionHandler` submits every operation that ran with reason
+    * `'operation'`, and `ModelSubmissionHandler` ends that submission with a
+    * `setDirtyState` carrying it. A declined operation sends none,
+    * so an action of this kind from something else, such as a late submission
+    * of the load, cannot pass for the operation's. The driver's session must
+    * receive `setDirtyState`.
+    */
    readonly expectedResponseKind: string;
    /**
     * Returns whether the source model gained the element — the adopter reads its
@@ -80,8 +99,12 @@ export interface GlspCreateOperationSpec<TAction, TDriver extends GlspConformanc
     * fixture to its input document, so a fixture whose input was MUTATED by an
     * earlier check silently expects the wrong number. Give each check pristine
     * input, or take the delta route above.
+    *
+    * May answer asynchronously. It runs once the response kind has arrived, and
+    * a write observed from another process, a `workspace/applyEdit` say, can
+    * arrive after that.
     */
-   readonly expectMutated: (driver: TDriver) => boolean;
+   readonly expectMutated: (driver: TDriver) => boolean | Promise<boolean>;
 }
 
 /**
@@ -132,10 +155,44 @@ export interface GlspConformanceOptions<TAction, TDriver extends GlspConformance
    readonly connect: () => TDriver | Promise<TDriver>;
    /** Per-diagram-type fixtures. */
    readonly diagrams: ReadonlyArray<GlspFixture<TAction, TDriver>>;
-   /** Suite title override. Default `'conformance: glsp'`. */
+   /** Suite title override. Default `'glsp conformance'`. */
    readonly suiteTitle?: string;
 }
 
+/** GLSP's `SetDirtyStateAction.KIND`, named here because the kit imports no GLSP type. */
+const SET_DIRTY_STATE_KIND = 'setDirtyState';
+
+/** The reason GLSP's `OperationActionHandler` submits an operation that ran with, which its dirty state carries. */
+const OPERATION_REASON = 'operation';
+
+function isOperationReceipt(action: unknown): boolean {
+   return typeof action === 'object' && action !== null && 'reason' in action && action.reason === OPERATION_REASON;
+}
+
+/**
+ * Resolve once the operation's receipt arrives, passing over a dirty state
+ * with any other reason. Rejects with the wait's own failure, which may be a
+ * closed connection rather than a missing receipt.
+ */
+async function nextOperationReceipt<TAction>(driver: GlspConformanceDriver<TAction>): Promise<void> {
+   for (;;) {
+      let dirtyState: TAction;
+      try {
+         dirtyState = await driver.nextAction(SET_DIRTY_STATE_KIND);
+      } catch (error: unknown) {
+         const reason = describeError(error);
+         throw new Error(
+            `Waiting for the operation's receipt, a ${SET_DIRTY_STATE_KIND} with reason '${OPERATION_REASON}', failed: ${reason}. ` +
+               `If none arrived in time, either no operation ran or the session does not declare ${SET_DIRTY_STATE_KIND}.`,
+            { cause: error }
+         );
+      }
+      if (isOperationReceipt(dirtyState)) {
+         return;
+      }
+   }
+}
+
 /**
  * Build the GLSP check battery — per diagram type: `start()` resolves;
  * `RequestModel` responds with the expected kind (+ optional `expectResponse`
@@ -195,9 +252,10 @@ export function buildGlspChecks<TAction, TDriver extends GlspConformanceDriver<T
                   driver.dispatch(diagram.requestModel());
                   await driver.nextAction(diagram.expectedResponseKind);
                   driver.dispatch(operation.action(driver));
+                  await nextOperationReceipt(driver);
                   await driver.nextAction(operation.expectedResponseKind);
                   assert.ok(
-                     operation.expectMutated(driver),
+                     await operation.expectMutated(driver),
                      'expectMutated was false — the create operation did not mutate the source model'
                   );
                } finally {

package/src/glsp/node/index.ts

@@ -0,0 +1,274 @@
+/********************************************************************************
+ * Copyright (c) 2026 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
+ ********************************************************************************/
+
+/**
+ * The `@hydranium/conformance/glsp/node` subpath: a socket driver for the
+ * {@link GlspConformanceDriver} port, over a real TCP socket, for proving a
+ * deployed GLSP server rather than a container built in the test process.
+ *
+ * It speaks GLSP's JSON-RPC by method name, so like the rest of the kit it names
+ * no `@eclipse-glsp/*` type and the adopter's fixtures supply every action.
+ */
+
+import { randomUUID } from 'node:crypto';
+import * as net from 'node:net';
+import { createMessageConnection, SocketMessageReader, SocketMessageWriter, type MessageConnection } from 'vscode-jsonrpc/node';
+import type { GlspConformanceDriver } from '../index.js';
+
+const DEFAULT_PROTOCOL_VERSION = '1.0.0';
+
+const DEFAULT_TIMEOUT_MS = 15_000;
+
+/** Configuration for {@link connectGlspSocketDriver}. */
+export interface GlspSocketDriverOptions<TAction extends { readonly kind: string } = { readonly kind: string }> {
+   readonly port: number;
+   /** Defaults to `127.0.0.1`. */
+   readonly host?: string;
+   /** The diagram type the client session is opened for. */
+   readonly diagramType: string;
+   /**
+    * The action kinds this client handles, which the server routes back to it.
+    * Declare every kind the server sends during the checks: one it sends that
+    * neither side handles fails the server's dispatch, and the session gets a
+    * rejected request or an error message instead.
+    */
+   readonly clientActionKinds: readonly string[];
+   /** Defaults to a fresh id per driver, so drivers sharing one server never share a session. */
+   readonly clientSessionId?: string;
+   readonly applicationId?: string;
+   /**
+    * The GLSP protocol version announced in `initialize`. The server refuses
+    * `initialize` unless it equals its own, so a server on a newer protocol
+    * needs this. Defaults to `1.0.0`.
+    */
+   readonly protocolVersion?: string;
+   /**
+    * The client's reply to a received action, sent back to the server, or
+    * `undefined` for none. A server that lays out on the client finishes a
+    * `requestModel` only once its `requestBounds` is answered with
+    * `computedBounds`, so a load without this stops half way. A reply is not a
+    * dispatch, as the GLSP client's own is an automatic answer to the server,
+    * so it leaves the point `nextAction` matches from where it was. A throw
+    * fails every pending and later wait with it.
+    */
+   readonly respond?: (action: TAction) => TAction | undefined;
+   /** Default bound for {@link GlspConformanceDriver.nextAction}, and the bound on the TCP connect and on each `start()` request. */
+   readonly timeoutMs?: number;
+}
+
+/** A {@link GlspConformanceDriver} over a socket, with the actions it received. */
+export interface GlspSocketDriver<TAction extends { readonly kind: string }> extends GlspConformanceDriver<TAction> {
+   /** Every action the server sent to this session, in arrival order; append-only. */
+   readonly actions: ReadonlyArray<TAction>;
+}
+
+/** GLSP's `process` notification payload, in either direction. */
+interface ActionMessage<TAction> {
+   readonly clientId: string;
+   readonly action: TAction;
+}
+
+function isActionMessage(value: unknown): value is ActionMessage<{ readonly kind: string }> {
+   if (typeof value !== 'object' || value === null || !('clientId' in value) || !('action' in value)) {
+      return false;
+   }
+   const { action } = value;
+   return typeof action === 'object' && action !== null && 'kind' in action && typeof action.kind === 'string';
+}
+
+/**
+ * Open a TCP connection to a GLSP server and wrap it as a driver. The session is
+ * not initialised until the kit calls `start()`.
+ */
+export async function connectGlspSocketDriver<TAction extends { readonly kind: string }>(
+   options: GlspSocketDriverOptions<TAction>
+): Promise<GlspSocketDriver<TAction>> {
+   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+   const clientSessionId = options.clientSessionId ?? `glsp-socket-${randomUUID()}`;
+   const socket = await openSocket(options.host ?? '127.0.0.1', options.port, timeoutMs);
+   const connection: MessageConnection = createMessageConnection(new SocketMessageReader(socket), new SocketMessageWriter(socket), console);
+
+   const actions: TAction[] = [];
+   const send = (action: TAction): void => {
+      // Fire-and-forget, so neither a closed connection, which throws here, nor
+      // a failed write reaches the caller; the wait that follows reports it.
+      try {
+         connection.sendNotification('process', { clientId: clientSessionId, action }).catch(() => undefined);
+      } catch {
+         // Already reported by the closed state every later wait reads.
+      }
+   };
+   const consumed = new WeakSet<TAction>();
+   // Where the last dispatch fell in `actions`; a wait matches only from here.
+   let dispatchedAt = 0;
+   const waiters: Array<{ readonly kind: string; readonly resolve: (action: TAction) => void; readonly fail: (error: Error) => void }> = [];
+   // Why no awaited action can arrive any more, once something ended the session.
+   let ended: { readonly reason: string; readonly cause?: unknown } | undefined;
+
+   // A wait still pending when the session ends fails at once, naming why,
+   // rather than at its timeout reading like a declined operation.
+   function end(reason: string, cause?: unknown): void {
+      ended ??= { reason, cause };
+      for (const waiter of waiters.splice(0)) {
+         waiter.fail(new Error(`${ended.reason} while waiting for '${waiter.kind}'`, { cause: ended.cause }));
+      }
+   }
+   const closedReason = `GLSP connection to session ${clientSessionId} closed`;
+   connection.onClose(() => end(closedReason));
+
+   connection.onNotification('process', (message: unknown) => {
+      if (!isActionMessage(message) || message.clientId !== clientSessionId) {
+         return;
+      }
+      // The fixture's own action type; the guard has checked the one field read here.
+      const action = message.action as TAction;
+      actions.push(action);
+      const index = waiters.findIndex(waiter => waiter.kind === action.kind);
+      if (index >= 0) {
+         const [waiter] = waiters.splice(index, 1);
+         consumed.add(action);
+         waiter.resolve(action);
+      }
+      // The connection only logs a handler's throw, so a fixture bug would
+      // otherwise surface as an unrelated wait timing out.
+      let reply: TAction | undefined;
+      try {
+         reply = options.respond?.(action);
+      } catch (error: unknown) {
+         end(`respond threw on '${action.kind}' (${String(error)})`, error);
+         return;
+      }
+      if (reply) {
+         send(reply);
+      }
+   });
+   connection.listen();
+
+   let disposed = false;
+
+   return {
+      actions,
+
+      async start(): Promise<void> {
+         // Bounded, so a server that accepts the socket and never answers fails
+         // naming the request, when the runner's own timeout is the longer one.
+         await within(
+            connection.sendRequest('initialize', {
+               applicationId: options.applicationId ?? 'hydranium-conformance',
+               protocolVersion: options.protocolVersion ?? DEFAULT_PROTOCOL_VERSION
+            }),
+            timeoutMs,
+            'initialize'
+         );
+         await within(
+            connection.sendRequest('initializeClientSession', {
+               clientSessionId,
+               diagramType: options.diagramType,
+               clientActionKinds: options.clientActionKinds
+            }),
+            timeoutMs,
+            'initializeClientSession'
+         );
+      },
+
+      dispatch(action: TAction): void {
+         dispatchedAt = actions.length;
+         send(action);
+      },
+
+      nextAction<T extends TAction = TAction>(kind: string, waitMs = timeoutMs): Promise<T> {
+         const existing = actions.find((action, index) => index >= dispatchedAt && action.kind === kind && !consumed.has(action));
+         if (existing) {
+            consumed.add(existing);
+            return Promise.resolve(existing as T);
+         }
+         if (ended) {
+            return Promise.reject(new Error(`${ended.reason}; no '${kind}' action can arrive`, { cause: ended.cause }));
+         }
+         return new Promise<T>((resolve, reject) => {
+            const waiter = {
+               kind,
+               resolve: (action: TAction): void => {
+                  clearTimeout(timer);
+                  resolve(action as T);
+               },
+               fail: (error: Error): void => {
+                  clearTimeout(timer);
+                  reject(error);
+               }
+            };
+            const timer = setTimeout(() => {
+               const at = waiters.indexOf(waiter);
+               if (at >= 0) {
+                  waiters.splice(at, 1);
+               }
+               // Naming what did arrive tells an operation the server declined
+               // (a status or nothing at all) apart from a transport that hangs,
+               // split at the last dispatch, before which no match counts.
+               const kindsIn = (from: number, to?: number): string =>
+                  actions
+                     .slice(from, to)
+                     .map(action => action.kind)
+                     .join(', ') || 'nothing';
+               const seen =
+                  dispatchedAt === 0
+                     ? `received: ${kindsIn(0)}`
+                     : `received before the last dispatch, which a wait does not match: ${kindsIn(0, dispatchedAt)}; since: ${kindsIn(dispatchedAt)}`;
+               reject(new Error(`No '${kind}' action within ${waitMs}ms on session ${clientSessionId}; ${seen}`));
+            }, waitMs);
+            waiters.push(waiter);
+         });
+      },
+
+      dispose(): void {
+         if (disposed) {
+            return;
+         }
+         disposed = true;
+         // A disposed connection fires no close event, so the waits end here.
+         end(closedReason);
+         connection.dispose();
+         socket.destroy();
+      }
+   };
+}
+
+function within<T>(request: Promise<T>, timeoutMs: number, method: string): Promise<T> {
+   return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`GLSP server did not answer '${method}' within ${timeoutMs}ms`)), timeoutMs);
+      request.then(
+         value => {
+            clearTimeout(timer);
+            resolve(value);
+         },
+         (error: unknown) => {
+            clearTimeout(timer);
+            reject(error);
+         }
+      );
+   });
+}
+
+function openSocket(host: string, port: number, timeoutMs: number): Promise<net.Socket> {
+   return new Promise<net.Socket>((resolve, reject) => {
+      const socket = net.createConnection({ host, port });
+      const timer = setTimeout(() => {
+         socket.destroy();
+         reject(new Error(`TCP connect to GLSP server at ${host}:${port} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      socket.once('connect', () => {
+         clearTimeout(timer);
+         resolve(socket);
+      });
+      socket.once('error', error => {
+         clearTimeout(timer);
+         reject(error);
+      });
+   });
+}

package/src/jest/index.ts

@@ -57,7 +57,7 @@ const jestRunner: ConformanceRunner = {
 export function runDataConformance<TTransfer extends TransferElement, TDiagnostic extends TransferDiagnostic = TransferDiagnostic>(
    options: DataConformanceOptions<TTransfer, TDiagnostic>
 ): void {
-   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'conformance: data-server', buildDataChecks(options));
+   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'data-server conformance', buildDataChecks(options));
 }
 
 /**
@@ -66,7 +66,7 @@ export function runDataConformance<TTransfer extends TransferElement, TDiagnosti
  * per language) and a ran-vs-skipped summary.
  */
 export function runLspConformance(options: LspConformanceOptions): void {
-   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'conformance: lsp', buildLspChecks(options));
+   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'lsp conformance', buildLspChecks(options));
 }
 
 /**
@@ -77,5 +77,5 @@ export function runLspConformance(options: LspConformanceOptions): void {
 export function runGlspConformance<TAction, TDriver extends GlspConformanceDriver<TAction>>(
    options: GlspConformanceOptions<TAction, TDriver>
 ): void {
-   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'conformance: glsp', buildGlspChecks(options));
+   emitConformanceSuite(jestRunner, options.suiteTitle ?? 'glsp conformance', buildGlspChecks(options));
 }

package/src/lsp/index.ts

@@ -11,10 +11,11 @@
  * The `@hydranium/conformance/lsp` slice — protocol conformance for the LSP
  * head. The driver port is a STRUCTURAL minimum (`LspConformanceDriver`) that
  * `@hydranium/core/testing/node`'s `LspHarness` satisfies with NO adapter: the kit
- * names only `string`, plain coordinates, and tiny structural minima
+ * names only strings, plain coordinates, and tiny structural minima
  * (`{ message }`, `{ items }`, `{ capabilities }`), never
  * `vscode-languageserver-protocol` wire types, so the harness's richer return
- * types are assignable to the narrower port.
+ * types are assignable to the narrower port. An alias of `string` is still a
+ * string for that purpose and stays inside the rule; a wire type does not.
  *
  * **This slice does not read `LanguageFixture.edit` at all.** The didChange
  * check drives `valid → invalid` using `invalid.text`, so there is no
@@ -23,9 +24,21 @@
  */
 
 import assert from 'node:assert/strict';
+import type { Locale } from '@hydranium/protocol';
 import type { Harness } from '@hydranium/protocol/testing';
 import type { ConformanceCheck } from '../conformance-suite.js';
-import { type LanguageFixture, resolveDeferred, resolveModel } from '../model.js';
+import { type ConformanceModel, type LanguageFixture, resolveDeferred, resolveModel } from '../model.js';
+
+/**
+ * Structural minimum of the `initialize` params the kit sends — only `locale`,
+ * which is the one field a check needs to vary.
+ *
+ * A real `InitializeParams` is assignable to this, so a driver typed against
+ * upstream's shape satisfies the port with no adapter.
+ */
+export interface LspConformanceInitializeParams {
+   readonly locale?: Locale;
+}
 
 /** Structural minimum of an LSP `InitializeResult` — only the baseline capabilities the kit asserts. */
 export interface LspConformanceInitializeResult {
@@ -76,8 +89,17 @@ function hasTextMessage(diagnostic: LspConformanceDiagnostic): boolean {
  * gives the kit the universal `dispose()` teardown.
  */
 export interface LspConformanceDriver extends Harness {
-   /** Drive the `initialize` → `initialized` handshake; resolve with the (structurally-minimal) result. */
-   initialize(): Promise<LspConformanceInitializeResult>;
+   /**
+    * Drive the `initialize` → `initialized` handshake; resolve with the
+    * (structurally-minimal) result.
+    *
+    * `params` is optional and every field in it is too, so a driver that ignores
+    * the argument entirely still satisfies this port — which is what keeps
+    * adding a field here from being a breaking change. `locale` is the reading
+    * user's language, declared by the client because only the client knows it;
+    * the render check below is the only caller that passes anything.
+    */
+   initialize(params?: LspConformanceInitializeParams): Promise<LspConformanceInitializeResult>;
    /** Send `didOpen` for `uri` with full `text` under `languageId`. */
    openDocument(uri: string, text: string, languageId: string, version?: number): void;
    /** Send `didChange` for `uri` as a single full-text replacement at `version`. */
@@ -101,7 +123,7 @@ export interface LspConformanceOptions {
    readonly connect: () => LspConformanceDriver | Promise<LspConformanceDriver>;
    /** Per-language fixtures; the grammar-bearing checks run once per language. */
    readonly languages: ReadonlyArray<LanguageFixture>;
-   /** Suite title override. Default `'conformance: lsp'`. */
+   /** Suite title override. Default `'lsp conformance'`. */
    readonly suiteTitle?: string;
 }
 
@@ -177,7 +199,7 @@ export function buildLspChecks(options: LspConformanceOptions): ConformanceCheck
    });
 
    for (const language of options.languages) {
-      const { valid, invalid, completionPosition } = language;
+      const { valid, invalid, completionPosition, renderedDiagnostic } = language;
       const tag = `[${valid.languageId}]`;
 
       checks.push({
@@ -273,7 +295,88 @@ export function buildLspChecks(options: LspConformanceOptions): ConformanceCheck
             skipReason: 'fixture supplied no completionPosition'
          });
       }
+
+      // Opt-in: server-side rendering runs only when the fixture names a locale
+      // and the sentence it expects in it. The framework ships no catalogue, so
+      // a server that renders nothing is CORRECT and must not be failed.
+      const renderTitle = `a diagnostic is published rendered in the locale initialize declared ${tag}`;
+      const renderControlTitle = `the same diagnostic is NOT rendered when no locale is declared ${tag}`;
+      if (renderedDiagnostic) {
+         checks.push({
+            title: renderTitle,
+            body: async () => {
+               const published = await publishedMessagesFor(connect, invalid, { locale: renderedDiagnostic.locale });
+               assert.ok(
+                  published.some(message => message.includes(renderedDiagnostic.expected)),
+                  `no published diagnostic contained ${JSON.stringify(renderedDiagnostic.expected)}: ${JSON.stringify(published)}`
+               );
+            }
+         });
+
+         // The second half of the pair. "Contains X" also passes for a server
+         // whose English contains X, and for one that renders whatever the
+         // locale — so the discriminating read is the fragment that must
+         // disappear. Reported as skipped rather than silently dropped when the
+         // fixture omits it, because a lone containment check IS weaker and a
+         // reader has to be able to see that from the report.
+         if (renderedDiagnostic.absentWithLocale) {
+            const { absentWithLocale } = renderedDiagnostic;
+            checks.push({
+               title: renderControlTitle,
+               body: async () => {
+                  const withLocale = await publishedMessagesFor(connect, invalid, { locale: renderedDiagnostic.locale });
+                  assert.ok(
+                     !withLocale.some(message => message.includes(absentWithLocale)),
+                     `a diagnostic still contained ${JSON.stringify(absentWithLocale)} with the locale declared: ${JSON.stringify(withLocale)}`
+                  );
+
+                  // And present without it, which is what rules out a fragment
+                  // that never appears in either state — a typo in the fixture
+                  // would otherwise make the assertion above pass for free.
+                  const withoutLocale = await publishedMessagesFor(connect, invalid);
+                  assert.ok(
+                     withoutLocale.some(message => message.includes(absentWithLocale)),
+                     `no diagnostic contained ${JSON.stringify(absentWithLocale)} with no locale declared, so it cannot witness the render: ${JSON.stringify(withoutLocale)}`
+                  );
+               }
+            });
+         } else {
+            checks.push({
+               title: renderControlTitle,
+               skipReason: 'fixture supplied no absentWithLocale, so the render check is a containment test only'
+            });
+         }
+      } else {
+         checks.push({ title: renderTitle, skipReason: 'fixture supplied no renderedDiagnostic (server-side rendering is opt-in)' });
+         checks.push({ title: renderControlTitle, skipReason: 'fixture supplied no renderedDiagnostic (server-side rendering is opt-in)' });
+      }
    }
 
    return checks;
 }
+
+/**
+ * Open `model` on a fresh driver and return the messages of the diagnostics
+ * published for it, as plain strings.
+ *
+ * A fresh driver per call because `initialize` is once-only per connection and
+ * the locale rides it — so the two states this compares cannot share one.
+ */
+async function publishedMessagesFor(
+   connect: LspConformanceOptions['connect'],
+   model: ConformanceModel,
+   params?: LspConformanceInitializeParams
+): Promise<string[]> {
+   const driver = await connect();
+   try {
+      await driver.initialize(params);
+      const resolved = resolveModel(model);
+      const diagnostics = driver.nextDiagnostics(resolved.uri);
+      driver.openDocument(resolved.uri, resolved.text, resolved.languageId);
+      return (await diagnostics).map(diagnostic =>
+         typeof diagnostic.message === 'string' ? diagnostic.message : (diagnostic.message?.value ?? '')
+      );
+   } finally {
+      driver.dispose();
+   }
+}