@hydranium/conformance 1.0.0-next.8 → 1.0.0-next.85

package/lib/model.d.ts

@@ -67,6 +67,45 @@ export interface EditSpec {
     readonly to: Deferred<string>;
     readonly expect: (root: unknown) => boolean;
 }
+/**
+ * A reference-picker query for an element that does not exist yet, plus the
+ * candidate the adopter expects it to offer.
+ *
+ * **The URI a create-element flow holds is a FOLDER**, because the file is not
+ * written until the dialog is confirmed. A folder URI names no file and so
+ * carries no extension, which is the one shape a head cannot route to a grammar
+ * by URI alone — it has to resolve the language some other way. That makes this
+ * the create dialog's load-bearing precondition and the reason the query is
+ * worth a conformance check of its own: a head that gets it wrong answers no
+ * candidates or throws, and the dialog never opens.
+ */
+export interface ReferenceQuerySpec {
+    /** AST type of the element being created — the synthetic source's own type. */
+    readonly type: string;
+    /** The reference property on the source (or on `syntheticPath`'s leaf) whose candidates the picker fills. */
+    readonly property: string;
+    /**
+     * Steps from the synthetic source down to the node holding `property`, when
+     * the reference is not on the source itself. Each step is
+     * `[containerProperty, type]` — the kit builds the `SyntheticStep`s, so the
+     * fixture names no protocol type.
+     */
+    readonly path?: ReadonlyArray<readonly [containerProperty: string, type: string]>;
+    /**
+     * Folder the create flow asks at. {@link Deferred} because a fixture may name
+     * a workspace the driver's `connect` only just created. Defaults to the parent
+     * of `valid.uri`, which is the folder a sibling of the valid model would go
+     * into — the common case, so most fixtures supply only `type` + `property`.
+     */
+    readonly folderUri?: Deferred<string>;
+    /**
+     * A candidate label the query MUST offer. Without it an empty result passes,
+     * and empty is exactly what the defect this check exists for produces — so
+     * the expectation is what makes the check discriminating rather than a
+     * smoke test.
+     */
+    readonly expectCandidate: string;
+}
 /**
  * The per-language fixture. `valid` and `invalid` are defined once and reused
  * across heads; the two extras are per-head opt-ins.
@@ -83,6 +122,9 @@ export interface EditSpec {
  *   uses `invalid.text` and never calls `edit.expect`, so an LSP-only adopter
  *   has nothing to supply here.
  * - `completionPosition` — read by the **LSP slice only**.
+ * - `referenceQuery` — read by the **data slice only**, and only when the
+ *   driver supplies `references` (the reference surface is opt-in on the head
+ *   too, so both halves have to be present for the check to run).
  *
  * Both extras are optional and their checks report *skipped* when absent,
  * rather than silently not running. Making either mandatory would defeat the
@@ -107,5 +149,67 @@ export interface LanguageFixture {
         readonly line: number;
         readonly character: number;
     };
+    /**
+     * Optional: the create-dialog reference query. Read by the **data slice
+     * only**, and only when the driver exposes the opt-in reference surface.
+     */
+    readonly referenceQuery?: ReferenceQuerySpec;
+    /**
+     * Optional: a second document that REFERENCES {@link valid}, so the data
+     * slice can provoke a CASCADE — a rebuild of this document caused by
+     * editing the one it points at, with its own text never touched.
+     *
+     * Opt-in because a grammar need not have cross-document references at all,
+     * and because only the adopter knows which pair of documents forms one.
+     * Supplying it IS the claim that editing `valid` rebuilds this document; the
+     * check then holds the head to reporting that on `onDocumentsBuilt`, which
+     * is the only channel that can carry it — the document has no subscriber and
+     * its file did not change, so neither the update channel nor a filesystem
+     * watcher can.
+     */
+    readonly dependent?: ConformanceModel;
+    /**
+     * Optional: a locale plus the sentence the server must publish in it. Read
+     * by the **LSP slice only**.
+     */
+    readonly renderedDiagnostic?: RenderedDiagnosticSpec;
+}
+/**
+ * A locale, and one sentence the server must produce in it for the `invalid`
+ * fixture.
+ *
+ * **Opt-in, and it has to be.** The framework ships no catalogue and selects no
+ * locale, so a server that installs no renderer correctly publishes English —
+ * mandating this check would fail every adopter without i18n for doing the right
+ * thing. Supplying the field is the adopter saying "I render server-side, hold me
+ * to it".
+ *
+ * `expected` is a SUBSTRING, not the whole message. The kit owns no grammar, so
+ * it cannot know how many diagnostics `invalid` produces or in what order, and
+ * an adopter should be able to pin the translated fragment without restating a
+ * sentence they may reword. A substring long enough to be wrong if the render
+ * did not happen is the whole requirement.
+ *
+ * `absentWithoutLocale` is what makes the check a pair rather than a single
+ * assertion: "the message contains X" also passes for a server whose English
+ * happens to contain X, and for one that renders regardless of locale. Naming
+ * the fragment that must DISAPPEAR when no locale is declared is what
+ * distinguishes those.
+ */
+export interface RenderedDiagnosticSpec {
+    /** The locale to declare at `initialize` — the tag whose catalogue the server has. */
+    readonly locale: string;
+    /** A fragment of the translated sentence, present in some diagnostic of the `invalid` fixture. */
+    readonly expected: string;
+    /**
+     * A fragment that must be absent once `locale` is declared, and present
+     * without it — normally a piece of the server's own English.
+     *
+     * Optional only because a catalogue may translate a message whose English
+     * shares no distinctive fragment with it. Omitting it drops the second half
+     * of the pair and leaves a check that a render-nothing server can pass; the
+     * kit reports that rather than pretending otherwise.
+     */
+    readonly absentWithLocale?: string;
 }
 //# sourceMappingURL=model.d.ts.map

package/lib/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAClC;AAED,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACxB;AAED,8CAA8C;AAC9C,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAExD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,wBAAwB,CAM9E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACtB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,eAAe;IAC7B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,kFAAkF;IAClF,QAAQ,CAAC,kBAAkB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CACtF"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAClC;AAED,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACxB;AAED,8CAA8C;AAC9C,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAExD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,wBAAwB,CAM9E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACtB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;CAC9C;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6GAA6G;IAC7G,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAClF;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,eAAe;IAC7B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,kFAAkF;IAClF,QAAQ,CAAC,kBAAkB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACpF;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IAC7C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,sBAAsB;IACpC,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kGAAkG;IAClG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACrC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydranium/conformance",
-  "version": "1.0.0-next.8",
+  "version": "1.0.0-next.85",
   "description": "Protocol conformance kit (TCK) for hydranium adopters. Per-head slices (/data, /lsp, /glsp) of fixture-parameterized, protocol-only smoke checks an adopter runs against its own server.",
   "keywords": [
     "hydranium",
@@ -88,7 +88,7 @@
     "watch": "tsc -b -w --preserveWatchOutput"
   },
   "devDependencies": {
-    "@hydranium/protocol": "1.0.0-next.8",
+    "@hydranium/protocol": "1.0.0-next.85",
     "@jest/globals": "^29.7.0",
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
@@ -98,7 +98,7 @@
     "vitest": "^4.0.0"
   },
   "peerDependencies": {
-    "@hydranium/protocol": "1.0.0-next.8",
+    "@hydranium/protocol": "1.0.0-next.85",
     "@jest/globals": "^29.0.0",
     "vitest": "^4.0.0"
   },

package/src/data/index.ts

@@ -10,24 +10,36 @@
 /**
  * The `@hydranium/conformance/data` slice — protocol conformance for the
  * data-server head. The driver port IS the protocol-native
- * {@link DataServerProtocol} proxy (plus the captured `onDocumentUpdated`
- * events), so no upstream wire-lib dep enters the kit and `DataServerHarness`
- * satisfies the port structurally with no adapter.
+ * {@link DataServerProtocol} proxy (plus the captured client notifications),
+ * so no upstream wire-lib dep enters the kit and `DataServerHarness` satisfies
+ * the port structurally with no adapter.
  */
 
 import assert from 'node:assert/strict';
-import { TransferDocument, type TransferDiagnostic, type TransferElement } from '@hydranium/protocol';
-import type { DataServerProtocol, TransferDocumentUpdatedEvent } from '@hydranium/protocol/data';
+import {
+   isConflictError,
+   ReferenceSource,
+   SyntheticStep,
+   TransferDocument,
+   type TransferDiagnostic,
+   type TransferElement
+} from '@hydranium/protocol';
+import type {
+   DataServerProtocol,
+   ReferenceServerProtocol,
+   TransferDocumentsBuiltEvent,
+   TransferDocumentUpdatedEvent
+} from '@hydranium/protocol/data';
 import { type Harness, waitFor } from '@hydranium/protocol/testing';
 import type { ConformanceCheck } from '../conformance-suite.js';
 import { type LanguageFixture, resolveDeferred, resolveModel } from '../model.js';
 
 /**
  * The data-server driver port — a live, connected, READY data-server exposed
- * through its protocol-native proxy plus the captured client-side update
- * events. The kit names only `@hydranium/protocol` types, so a
+ * through its protocol-native proxy plus the captured client-side
+ * notifications. The kit names only `@hydranium/protocol` types, so a
  * `DataServerHarness` satisfies the port structurally (it has `proxy` +
- * `events` + `dispose`) with NO adapter. `extends Harness` gives the kit the
+ * `events`, `builds` and `dispose`) with NO adapter. `extends Harness` gives the kit the
  * universal `dispose()` teardown.
  *
  * The kit seeds documents purely through the proxy: `updateModelDocument` is
@@ -43,6 +55,17 @@ export interface DataConformanceDriver<
    readonly proxy: DataServerProtocol<TTransfer, TDiagnostic>;
    /** Captured `onDocumentUpdated` events, append order — the subscription check's observation target. */
    readonly events: ReadonlyArray<TransferDocumentUpdatedEvent<TTransfer, TDiagnostic>>;
+   /** Captured `onDocumentsBuilt` events, append order — the cascade check's observation target. */
+   readonly builds: ReadonlyArray<TransferDocumentsBuiltEvent>;
+   /**
+    * The opt-in reference surface, when the head serves it.
+    *
+    * Separate from {@link proxy} because `ReferenceServerProtocol` is NOT part
+    * of `DataServerProtocol` — a head may serve documents and no references at
+    * all. Absent means the reference check reports skipped with a named reason
+    * rather than failing a head that never claimed the surface.
+    */
+   readonly references?: ReferenceServerProtocol<TTransfer>;
 }
 
 /** Options for `runDataConformance`. */
@@ -91,7 +114,7 @@ const SEEDER = 'conformance-seeder';
  * unit tests; adopters call `runDataConformance`.
  *
  * `LanguageFixture.edit` is read HERE and nowhere else in the kit, and is
- * optional: its two checks report skipped when it is absent. See
+ * optional: every check that needs one reports skipped when it is absent. See
  * {@link LanguageFixture} for which slice reads which field.
  */
 export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic extends TransferDiagnostic = TransferDiagnostic>(
@@ -178,7 +201,7 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
    });
 
    for (const language of options.languages) {
-      const { valid, invalid, edit } = language;
+      const { valid, invalid, edit, dependent } = language;
       const tag = `[${valid.languageId}]`;
 
       checks.push({
@@ -189,7 +212,7 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
                // Resolved AFTER `connect`, which is the whole point of allowing a
                // thunk: the fixture may name a workspace `connect` just created.
                const model = resolveModel(valid);
-               await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text });
+               await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text, basedOn: 'anything' });
                // `includeDiagnostics` for the same reason the invalid check
                // passes it: a synchronous read settles at the integrity-settled
                // phase, so an empty array without it can mean "validation has
@@ -224,7 +247,7 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
             const driver = await connect();
             try {
                const model = resolveModel(invalid);
-               await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text });
+               await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text, basedOn: 'anything' });
                // Diagnostics are a validation-phase product; a synchronous read settles at the
                // integrity-settled phase by default, so request validation explicitly here.
                // Safe despite `includeDiagnostics` waiting rather than forcing a build: the
@@ -237,6 +260,101 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
          }
       });
 
+      checks.push({
+         title: `a diagnostic carrying a framework message code also carries its params ${tag}`,
+         body: async () => {
+            const driver = await connect();
+            try {
+               const model = resolveModel(invalid);
+               await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text, basedOn: 'anything' });
+               const document = await driver.proxy.getModelDocument({ uri: model.uri, includeDiagnostics: true });
+
+               // Conditional rather than fixture-driven, and deliberately so: what
+               // an `invalid` fixture provokes is the adopter's choice, and a
+               // syntactic error legitimately carries no identity at all. The
+               // invariant is that the identity travels WHOLE or not — a `code`
+               // without `params` is the half-state that renders a translated
+               // template with its placeholders left standing, and it is
+               // reachable only by overriding `toTransferDiagnostic`.
+               const halfIdentities = document.diagnostics.filter(
+                  diagnostic =>
+                     typeof diagnostic.code === 'string' && diagnostic.code.startsWith('hydranium/') && diagnostic.params === undefined
+               );
+               assert.deepStrictEqual(
+                  halfIdentities.map(diagnostic => diagnostic.code),
+                  [],
+                  'diagnostics carry a framework message code with no params, so a translating surface cannot render them'
+               );
+            } finally {
+               driver.dispose();
+            }
+         }
+      });
+
+      // The create-dialog query, and the reason it is its own check: it is the
+      // only request a head receives whose URI names no file. Everything else
+      // in this battery addresses a document, so a head that routes purely by
+      // URI extension passes all of them and still cannot open a create dialog.
+      //
+      // Doubly opt-in — the fixture must name a query AND the driver must serve
+      // the reference surface — because either half missing means the head never
+      // claimed this behaviour. The reasons are reported separately so a skip
+      // says which half is absent.
+      const referenceQuery = language.referenceQuery;
+      const referenceSkipReason = !referenceQuery
+         ? 'fixture supplies no `referenceQuery` (omit it if this language has no create-element dialog)'
+         : undefined;
+
+      checks.push({
+         title: `findReferenceCandidates answers for a synthetic source at a folder URI ${tag}`,
+         skipReason: referenceSkipReason,
+         body: referenceQuery
+            ? async () => {
+                 const driver = await connect();
+                 try {
+                    if (!driver.references) {
+                       // Checked here rather than in `skipReason`: the driver only
+                       // exists once `connect` has run, and skip reasons are
+                       // computed while the battery is being planned.
+                       return;
+                    }
+                    const model = resolveModel(valid);
+                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text, basedOn: 'anything' });
+
+                    // Default to the folder holding the valid model: a sibling of
+                    // it is where a create flow would put the new file.
+                    const folderUri = referenceQuery.folderUri
+                       ? resolveDeferred(referenceQuery.folderUri)
+                       : model.uri.slice(0, model.uri.lastIndexOf('/'));
+                    assert.ok(
+                       folderUri.length > 0 && folderUri !== model.uri,
+                       `could not derive a folder URI from ${model.uri}; supply referenceQuery.folderUri`
+                    );
+
+                    const candidates = await driver.references.findReferenceCandidates({
+                       source: ReferenceSource.synthetic(folderUri, referenceQuery.type),
+                       syntheticPath: referenceQuery.path?.map(([containerProperty, type]) => SyntheticStep.of(containerProperty, type)),
+                       property: referenceQuery.property
+                    });
+
+                    // The expected label, not merely a non-empty array: the defect
+                    // this guards against answers `[]`, and an empty result is
+                    // also what a head with a genuinely empty index answers, so
+                    // only a named candidate tells the two apart.
+                    const labels = candidates.map(candidate => candidate.label);
+                    assert.ok(
+                       labels.includes(referenceQuery.expectCandidate),
+                       `findReferenceCandidates at the folder ${folderUri} did not offer ${JSON.stringify(
+                          referenceQuery.expectCandidate
+                       )}; got [${labels.join(', ')}]`
+                    );
+                 } finally {
+                    driver.dispose();
+                 }
+              }
+            : undefined
+      });
+
       // Opt-in: both remaining checks need a second, observably different model
       // text, which only `edit` supplies.
       const editSkipReason = 'fixture supplies no `edit` (data-slice only; omit it if this language is not driven through the data head)';
@@ -249,8 +367,13 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
                  const driver = await connect();
                  try {
                     const model = resolveModel(valid);
-                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text });
-                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: resolveDeferred(edit.to) });
+                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: model.text, basedOn: 'anything' });
+                    await driver.proxy.updateModelDocument({
+                       uri: model.uri,
+                       clientId: AUTHOR,
+                       model: resolveDeferred(edit.to),
+                       basedOn: 'anything'
+                    });
                     const document = await driver.proxy.getModelDocument({ uri: model.uri });
                     assert.ok(edit.expect(document.root), 'edit.expect(root) was false — the edit was not reflected by a follow-up get');
                  } finally {
@@ -260,6 +383,108 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
             : undefined
       });
 
+      checks.push({
+         title: `updateModelDocument arms the conflict gate on a based-on snapshot version ${tag}`,
+         skipReason: edit ? undefined : editSkipReason,
+         body: edit
+            ? async () => {
+                 const driver = await connect();
+                 try {
+                    const model = resolveModel(valid);
+                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: SEEDER, model: model.text, basedOn: 'anything' });
+
+                    // The version the gate is meant to accept, read BEFORE the
+                    // foreign edit that supersedes it.
+                    const stale = await driver.proxy.getModelDocument({ uri: model.uri });
+                    await driver.proxy.updateModelDocument({
+                       uri: model.uri,
+                       clientId: SEEDER,
+                       model: resolveDeferred(edit.to),
+                       basedOn: 'anything'
+                    });
+
+                    let rejection: unknown;
+                    await driver.proxy
+                       .updateModelDocument({
+                          uri: model.uri,
+                          clientId: AUTHOR,
+                          model: model.text,
+                          basedOn: stale.version
+                       })
+                       .catch((error: unknown) => {
+                          rejection = error;
+                       });
+                    assert.ok(
+                       isConflictError(rejection),
+                       `a write based on the superseded v${stale.version} was not refused: ${String(rejection)}`
+                    );
+
+                    // The other half, and it is not optional: a head that refused
+                    // EVERY write would satisfy the assertion above on its own, so
+                    // the gate has to be shown accepting a current snapshot too.
+                    const fresh = await driver.proxy.getModelDocument({ uri: model.uri });
+                    await driver.proxy.updateModelDocument({
+                       uri: model.uri,
+                       clientId: AUTHOR,
+                       model: resolveDeferred(edit.to),
+                       basedOn: fresh.version
+                    });
+                 } finally {
+                    driver.dispose();
+                 }
+              }
+            : undefined
+      });
+
+      // Opt-in twice over: the cascade needs an edit to provoke it AND a second
+      // document that references the first to be provoked.
+      const cascadeSkipReason =
+         'fixture supplies no `dependent` (a document referencing `valid`), so no cascade can be provoked over the protocol';
+
+      checks.push({
+         title: `editing a document reports its unwatched dependent as built ${tag}`,
+         skipReason: edit && dependent ? undefined : dependent ? editSkipReason : cascadeSkipReason,
+         body:
+            edit && dependent
+               ? async () => {
+                    const driver = await connect();
+                    try {
+                       const model = resolveModel(valid);
+                       const other = resolveModel(dependent);
+                       await driver.proxy.updateModelDocument({ uri: model.uri, clientId: SEEDER, model: model.text, basedOn: 'anything' });
+                       await driver.proxy.updateModelDocument({ uri: other.uri, clientId: SEEDER, model: other.text, basedOn: 'anything' });
+                       // Watch ONLY the referenced document. The dependent is left
+                       // unwatched on purpose: that is the state in which no other
+                       // channel can report it, and the state a workspace view is in
+                       // for every document it displays without opening.
+                       await driver.proxy.watchModelDocument({ uri: model.uri, clientId: SUBSCRIBER });
+                       const before = driver.builds.length;
+
+                       await driver.proxy.updateModelDocument({
+                          uri: model.uri,
+                          clientId: AUTHOR,
+                          model: resolveDeferred(edit.to),
+                          basedOn: 'anything'
+                       });
+
+                       await waitFor(() => driver.builds.slice(before).some(event => event.uris.includes(other.uri)), {
+                          message: `no onDocumentsBuilt event named ${other.uri} after editing the document it references`
+                       });
+                       const reported = driver.builds.slice(before).flatMap(event => [...event.uris]);
+                       // The watched document is excluded: its watcher already heard
+                       // about it on the update channel, and repeating it here would
+                       // be the bandwidth the per-URI gate exists to avoid.
+                       assert.ok(
+                          !reported.includes(model.uri),
+                          `onDocumentsBuilt named the WATCHED ${model.uri}; it is reported on the update channel instead`
+                       );
+                    } finally {
+                       driver.dispose();
+                    }
+                 }
+               : undefined
+      });
+
       checks.push({
          title: `subscribe + update delivers an onDocumentUpdated event with the originating clientId ${tag}`,
          skipReason: edit ? undefined : editSkipReason,
@@ -268,9 +493,14 @@ export function buildDataChecks<TTransfer extends TransferElement, TDiagnostic e
                  const driver = await connect();
                  try {
                     const model = resolveModel(valid);
-                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: SEEDER, model: model.text });
+                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: SEEDER, model: model.text, basedOn: 'anything' });
                     await driver.proxy.watchModelDocument({ uri: model.uri, clientId: SUBSCRIBER });
-                    await driver.proxy.updateModelDocument({ uri: model.uri, clientId: AUTHOR, model: resolveDeferred(edit.to) });
+                    await driver.proxy.updateModelDocument({
+                       uri: model.uri,
+                       clientId: AUTHOR,
+                       model: resolveDeferred(edit.to),
+                       basedOn: 'anything'
+                    });
                     await waitFor(() => driver.events.some(event => event.sourceClientId === AUTHOR), {
                        message: `no onDocumentUpdated event for ${model.uri} after the post-subscription update`
                     });

package/src/lsp/index.ts

@@ -25,7 +25,18 @@
 import assert from 'node:assert/strict';
 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?: string;
+}
 
 /** Structural minimum of an LSP `InitializeResult` — only the baseline capabilities the kit asserts. */
 export interface LspConformanceInitializeResult {
@@ -51,10 +62,20 @@ export interface LspConformanceDiagnostic {
    readonly message: string | { readonly value: string };
 }
 
-/** True when `diagnostic` carries a message in either LSP shape (plain string or markup). */
+/**
+ * True when `diagnostic` carries a NON-EMPTY message in either LSP shape
+ * (plain string or markup).
+ *
+ * Emptiness is part of the claim, not a refinement of it: `message: ''` is a
+ * diagnostic a user cannot act on, and a type-only test admits it — which
+ * makes "every diagnostic carries a message" pass for a head that publishes
+ * none. LSP declares the field required without forbidding the empty string,
+ * so nothing upstream rules it out either.
+ */
 function hasTextMessage(diagnostic: LspConformanceDiagnostic): boolean {
    const { message } = diagnostic;
-   return typeof message === 'string' || typeof message?.value === 'string';
+   const text = typeof message === 'string' ? message : message?.value;
+   return typeof text === 'string' && text.length > 0;
 }
 
 /**
@@ -66,8 +87,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`. */
@@ -167,7 +197,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({
@@ -199,7 +229,7 @@ export function buildLspChecks(options: LspConformanceOptions): ConformanceCheck
                driver.openDocument(model.uri, model.text, model.languageId);
                const published = await diagnostics;
                assert.ok(published.length >= 1, 'didOpen(invalid) published no diagnostics');
-               assert.ok(published.every(hasTextMessage), 'a published diagnostic was missing a message');
+               assert.ok(published.every(hasTextMessage), 'a published diagnostic was missing a non-empty message');
             } finally {
                driver.dispose();
             }
@@ -263,7 +293,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();
+   }
+}