@hydranium/glsp-server 1.0.0-next.79 → 1.0.0-next.85

package/src/state/reconciling-multi-document-glsp-state.ts

@@ -10,7 +10,7 @@
 import { type JsonModelState } from '@eclipse-glsp/server';
 import { injectable } from 'inversify';
 import { type AstNode } from '@hydranium/langium';
-import { type TransferElement } from '@hydranium/protocol';
+import { type BasedOn, type TransferElement } from '@hydranium/protocol';
 import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
 import { reconcileSourceModelWrite } from './reconcile-source-model-write.js';
 
@@ -71,8 +71,8 @@ export interface MultiDocumentSourceModel<TPrimary extends TransferElement = Tra
  * than reconciled. Gating them too would need a per-document reconcile whose
  * outcomes can disagree (merge one, conflict another) with no way to un-write the
  * merged one — the atomicity problem again, one layer up. An adopter that wants
- * a coarser check overrides {@link secondaryBaseVersion} to return the version
- * {@link AbstractHydraniumGlspState.capturedVersionOf} already holds, and takes
+ * a coarser check overrides {@link secondaryBasedOn} to return the version
+ * {@link AbstractHydraniumGlspState.snapshotVersionOf} already holds, and takes
  * on the partial-write window named there.
  */
 @injectable()
@@ -140,10 +140,10 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
     * `ConflictError` from the primary, reconcile via the injected policy exactly
     * as the single-document state does — the orchestration is shared.
     */
-   async updateSourceModel(model: MultiDocumentSourceModel<TPrimary>, version?: number): Promise<void> {
-      return reconcileSourceModelWrite<MultiDocumentSourceModel<TPrimary>>(model, version, {
-         persist: async (candidate, baseVersion) => {
-            const { root } = await this.persist(candidate, baseVersion);
+   async updateSourceModel(model: MultiDocumentSourceModel<TPrimary>, basedOn: BasedOn = this.basedOn): Promise<void> {
+      return reconcileSourceModelWrite<MultiDocumentSourceModel<TPrimary>>(model, basedOn, {
+         persist: async (candidate, candidateBasedOn) => {
+            const { root } = await this.persist(candidate, candidateBasedOn);
             this.setSourceRoot(this._sourceUri, root);
          },
          refetch: () => this.refetch(),
@@ -156,11 +156,11 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
 
    /**
     * Write hook — secondaries first (ungated), primary last (gated on
-    * `baseVersion`). The order is the failure-mode choice documented on the
+    * `basedOn`). The order is the failure-mode choice documented on the
     * class, not incidental: override this when the primary is the document the
     * others REFERENCE, since then this order writes the references first.
     */
-   protected async persist(model: MultiDocumentSourceModel<TPrimary>, baseVersion?: number): Promise<{ root: TRoot }> {
+   protected async persist(model: MultiDocumentSourceModel<TPrimary>, basedOn: BasedOn): Promise<{ root: TRoot }> {
       for (const [uri, secondary] of Object.entries(model.secondaries)) {
          if (this.hasChanged(this.baseline?.secondaries[uri], secondary)) {
             await this.persistSecondary(uri, secondary);
@@ -171,7 +171,7 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
          // captured rather than round-tripping the document for no reason.
          return { root: this._sourceRoot };
       }
-      return this.persistPrimary(model.primary, baseVersion);
+      return this.persistPrimary(model.primary, basedOn);
    }
 
    /**
@@ -194,19 +194,19 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
       return baseline === undefined || JSON.stringify(baseline) !== JSON.stringify(candidate);
    }
 
-   /** Write the primary document, opting into the conflict gate when `baseVersion` is given. */
-   protected async persistPrimary(model: TPrimary, baseVersion?: number): Promise<{ root: TRoot }> {
+   /** Write the primary document, opting into the conflict gate unless `basedOn` is `'anything'`. */
+   protected async persistPrimary(model: TPrimary, basedOn: BasedOn): Promise<{ root: TRoot }> {
       const document = await this.sharedServices.model.ModelService.update({
          uri: this._sourceUri,
          model,
          clientId: this.clientId,
-         baseVersion
+         basedOn
       });
       return document as unknown as { root: TRoot };
    }
 
    /**
-    * Write one secondary document, gated on whatever {@link secondaryBaseVersion}
+    * Write one secondary document, gated on whatever {@link secondaryBasedOn}
     * returns. Override alongside {@link persistPrimary} when the round-trip
     * differs per document role — a layout file and a semantic file need not
     * share a serializer.
@@ -216,17 +216,18 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
          uri,
          model,
          clientId: this.clientId,
-         baseVersion: this.secondaryBaseVersion(uri)
+         basedOn: this.secondaryBasedOn(uri)
       });
    }
 
    /**
-    * Based-on version for a secondary write. Default `undefined` — ungated, for
-    * the reason given under the conflict-gate note on the class doc.
+    * What a secondary write declares it was based on. Default `'anything'` —
+    * ungated, because gating the whole set needs a per-document reconcile whose
+    * outcomes can disagree, with no way to un-write an already-merged sibling.
     *
     * **The hook exists so that opting in is an override rather than a
-    * reimplementation.** The state already captures what such a check needs
-    * ({@link AbstractHydraniumGlspState.capturedVersionOf}), and returning that
+    * reimplementation.** The state already holds what such a check needs
+    * ({@link AbstractHydraniumGlspState.snapshotVersionOf}), and returning that
     * value here is the whole opt-in; without it the only place to put the
     * comparison is a copy of {@link persistSecondary}, which then has to be kept
     * in step with the framework's write call.
@@ -236,8 +237,8 @@ export class ReconcilingMultiDocumentGlspState<TRoot extends AstNode, TPrimary e
     * the reconcile then drops the edit those writes stay. Weigh that against the
     * default, which lets a foreign edit to a secondary be overwritten silently.
     */
-   protected secondaryBaseVersion(_uri: string): number | undefined {
-      return undefined;
+   protected secondaryBasedOn(_uri: string): BasedOn {
+      return 'anything';
    }
 
    /**

package/src/state/reconciling-transfer-hydranium-glsp-state.ts

@@ -10,7 +10,7 @@
 import { type JsonModelState } from '@eclipse-glsp/server';
 import { injectable } from 'inversify';
 import { type AstNode } from '@hydranium/langium';
-import { type TransferElement } from '@hydranium/protocol';
+import { type BasedOn, type TransferElement } from '@hydranium/protocol';
 import { AbstractHydraniumGlspState } from './abstract-hydranium-glsp-state.js';
 import { reconcileSourceModelWrite } from './reconcile-source-model-write.js';
 
@@ -84,13 +84,13 @@ export class ReconcilingTransferHydraniumGlspState<TRoot extends AstNode, TSourc
     * (force = last-writer-wins, reconciling = field-level merge) shared with
     * undo / redo.
     */
-   async updateSourceModel(model: TSourceModel, version?: number): Promise<void> {
+   async updateSourceModel(model: TSourceModel, basedOn: BasedOn = this.basedOn): Promise<void> {
       // Orchestration lives in `reconcileSourceModelWrite` so the multi-document
       // state gets the identical conflict handling; this method supplies only
       // the single-document meaning of persist / project.
-      return reconcileSourceModelWrite<TSourceModel>(model, version, {
-         persist: async (candidate, baseVersion) => {
-            const { root } = await this.persist(candidate, baseVersion);
+      return reconcileSourceModelWrite<TSourceModel>(model, basedOn, {
+         persist: async (candidate, candidateBasedOn) => {
+            const { root } = await this.persist(candidate, candidateBasedOn);
             this.setSourceRoot(this._sourceUri, root);
          },
          refetch: () => this.refetch(),
@@ -108,12 +108,12 @@ export class ReconcilingTransferHydraniumGlspState<TRoot extends AstNode, TSourc
     * round-trip differs override this; the orchestration in
     * {@link updateSourceModel} is unchanged.
     */
-   protected async persist(model: TSourceModel, baseVersion?: number): Promise<{ root: TRoot }> {
+   protected async persist(model: TSourceModel, basedOn: BasedOn): Promise<{ root: TRoot }> {
       const document = await this.sharedServices.model.ModelService.update({
          uri: this._sourceUri,
          model,
          clientId: this.clientId,
-         baseVersion
+         basedOn
       });
       return document as unknown as { root: TRoot };
    }

package/src/storage/hydranium-glsp-storage.ts

@@ -225,7 +225,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
    protected resubmitDebouncer!: Debouncer;
 
    /** Latest event document awaiting the debounced resubmit; read by {@link flushResubmit} (last write wins). */
-   protected pendingResubmitDocument?: AstDocument<AstNode, unknown>;
+   protected pendingResubmitDocument?: AstDocument<AstNode>;
 
    @postConstruct()
    protected init(): void {
@@ -376,7 +376,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * drag this client authors — the guard above gates the resubmit, not the
     * markers.
     */
-   protected handleSecondaryUpdated(uri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): void {
+   protected handleSecondaryUpdated(uri: string, event: AstDocumentUpdatedEvent<AstNode>): void {
       if (this.disposeIfStale(uri)) {
          return;
       }
@@ -402,7 +402,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * arrives pre-validation with an empty array — and diagnostics are the reason
     * {@link doUpdateAndSubmit} takes a separate event document at all.
     */
-   protected currentPrimaryDocument(): AstDocument<AstNode, unknown> | undefined {
+   protected currentPrimaryDocument(): AstDocument<AstNode> | undefined {
       const document = this.sharedServices.model.ModelService.getDocument(this.state.sourceUri);
       return document ? AstDocument.from(document) : undefined;
    }
@@ -415,7 +415,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * diagnostic markers for every update — including own edits, which skip
     * the resubmit but can still change diagnostics.
     */
-   protected async handleModelUpdated(rootUri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): Promise<void> {
+   protected async handleModelUpdated(rootUri: string, event: AstDocumentUpdatedEvent<AstNode>): Promise<void> {
       if (this.disposeIfStale(rootUri)) {
          return;
       }
@@ -447,7 +447,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * {@link resubmitDebouncer}, so a burst of rebuilds runs
     * {@link doUpdateAndSubmit} once with the most recent document.
     */
-   protected scheduleUpdateAndSubmit(document: AstDocument<AstNode, unknown>): void {
+   protected scheduleUpdateAndSubmit(document: AstDocument<AstNode>): void {
       this.pendingResubmitDocument = document;
       this.resubmitDebouncer.schedule();
    }
@@ -474,7 +474,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * mark our stack clean so the editor doesn't prompt to re-save identical
     * content. Our own saves already settle the stack through the save flow.
     */
-   protected handleModelSaved(event: AstDocumentSavedEvent<AstNode, unknown>): void {
+   protected handleModelSaved(event: AstDocumentSavedEvent<AstNode>): void {
       if (this.state.clientId !== event.sourceClientId) {
          this.commandStack.saveIsDone();
       }
@@ -488,7 +488,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * pre-validation, and this path re-settles precisely to escape a transient
     * mid-rebuild snapshot.
     */
-   protected async doUpdateAndSubmit(rootUri: string, eventDocument: AstDocument<AstNode, unknown>): Promise<Action[]> {
+   protected async doUpdateAndSubmit(rootUri: string, eventDocument: AstDocument<AstNode>): Promise<Action[]> {
       // Settle-gate the capture: never setSourceRoot off the event's possibly-transient
       // snapshot — the event can arrive while a re-entered document is mid-rebuild.
       const document = await this.sharedServices.model.ModelService.settled(rootUri);
@@ -526,7 +526,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * flip {@link AbstractHydraniumGlspState.editMode}, and — only on a transition —
     * return the {@link onParseErrorChanged} actions. No transition → no actions.
     */
-   protected refreshEditMode(document: AstDocument<AstNode, unknown>): Action[] {
+   protected refreshEditMode(document: AstDocument<AstNode>): Action[] {
       const broken = this.isStructurallyBroken(document);
       const previousEditMode = this.state.editMode;
       this.state.editMode = broken ? EditMode.READONLY : EditMode.EDITABLE;
@@ -543,7 +543,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * carrying a Langium `lexing-error` / `parsing-error` code. Adopters override
     * to compose additional break reasons.
     */
-   protected isStructurallyBroken(document: AstDocument<AstNode, unknown>): boolean {
+   protected isStructurallyBroken(document: AstDocument<AstNode>): boolean {
       return document.diagnostics.some(diagnostic => isStructuralDiagnostic(diagnostic));
    }
 
@@ -577,7 +577,7 @@ export class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string>
     * the validation clear a moment later. Measured on a browser host, polling the
     * overlay: no element, empty, the sentence, empty again.
     */
-   protected onParseErrorChanged(_document: AstDocument<AstNode, unknown>, broken: boolean): Action[] {
+   protected onParseErrorChanged(_document: AstDocument<AstNode>, broken: boolean): Action[] {
       return [
          SetEditModeAction.create(broken ? EditMode.READONLY : EditMode.EDITABLE),
          broken

package/src/validation/diagnostic-markers.ts

@@ -10,7 +10,7 @@
 import { type Marker, MarkerKind } from '@eclipse-glsp/protocol';
 import { type AstNode } from '@hydranium/langium';
 import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types';
-import { type TransferLspDiagnostic } from '@hydranium/core';
+import { type AstDiagnostic } from '@hydranium/core';
 
 /**
  * The model-shaped lookups the diagnostic→marker translation needs, injected so
@@ -48,7 +48,7 @@ export interface DiagnosticMarkerLookups {
  * `MarkersReason` so a fresh `SetMarkersAction` replaces the previous markers
  * (an empty result clears them when all errors are fixed).
  */
-export function diagnosticsToMarkers(diagnostics: readonly TransferLspDiagnostic[], lookups: DiagnosticMarkerLookups): Marker[] {
+export function diagnosticsToMarkers(diagnostics: readonly AstDiagnostic[], lookups: DiagnosticMarkerLookups): Marker[] {
    const markers: Marker[] = [];
    for (const diagnostic of diagnostics) {
       const kind = markerKind(diagnostic.severity);

package/src/validation/hydranium-glsp-model-validator.ts

@@ -12,7 +12,7 @@ import { type GModelElement, ModelState, type ModelValidator } from '@eclipse-gl
 import { inject, injectable } from 'inversify';
 import { type AstNode } from '@hydranium/langium';
 import { URI } from '@hydranium/langium';
-import { type ServerSharedServices, type TransferLspDiagnostic } from '@hydranium/core';
+import { type ServerSharedServices, type AstDiagnostic } from '@hydranium/core';
 import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
 import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
 import { type DiagnosticMarkerLookups, diagnosticsToMarkers } from './diagnostic-markers.js';
@@ -75,9 +75,9 @@ export class HydraniumGlspModelValidator<TRoot extends AstNode = AstNode> implem
             continue;
          }
          // Diagnostics are produced by the framework's `HydraniumDocumentValidator`,
-         // which emits `TransferLspDiagnostic` (LSP `Diagnostic` + `element` path).
+         // which emits `AstDiagnostic` (LSP `Diagnostic` + `element` path).
          // Parser/lexer diagnostics carry no `element`; the lookup drops them.
-         const diagnostics = document.diagnostics as TransferLspDiagnostic[] | undefined;
+         const diagnostics = document.diagnostics as AstDiagnostic[] | undefined;
          if (!diagnostics || diagnostics.length === 0) {
             continue;
          }