@hydranium/core 1.0.0-next.37 → 1.0.0-next.39

package/src/langium/integrity/integrity-service.ts

@@ -75,6 +75,11 @@ export namespace IntegrityService {
     * at `DocumentState.Validated` and delivered separately via `publishDiagnostics`
     * or the `onModelUpdated` event.
     *
+    * The AST is what this guarantees, not the text. For a closed document whose
+    * repair was STAGED rather than written (`'editor'` sync mode),
+    * `textDocument` still mirrors disk — read the repair off the AST, or from
+    * the staged content the next open consumes.
+    *
     * Invariant: integrity rules only register at Parsed or Linked, so the build
     * is guaranteed post-integrity once it advances past `onBuildPhase(Linked)`
     * into `IndexedReferences`. {@link IntegrityService.register} enforces this at
@@ -317,10 +322,11 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
          return;
       }
 
+      const version = document.textDocument.version;
       // Keep the same version so HydraniumTextDocuments doesn't reject subsequent client edits.
       // Use manager.update so the `instanceof FullTextDocument` gate in the bare
       // `TextDocument.update` doesn't trip on adopter-custom text-document types.
-      const textDocument = this.textDocuments.update(document.textDocument, [{ text: newText }], document.textDocument.version);
+      const textDocument = this.textDocuments.update(document.textDocument, [{ text: newText }], version);
 
       await this.syncCorrections(textDocument);
 
@@ -328,6 +334,14 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
          // Parsed-phase correction: re-parse only. The build pipeline still runs
          // IndexedContent → ComputedScopes → Linked → … on the fresh AST afterwards,
          // so the document reconciles naturally with no extra work here.
+         //
+         // Except for a closed document whose repair did not reach disk — `'editor'`
+         // sync mode stages it instead of writing it — where the re-parse is SKIPPED:
+         // Langium's factory gates the parse on the CST's `fullText`, which still
+         // equals the disk text the same call re-reads and redefines `textDocument`
+         // over. So `document.textDocument` is NOT post-integrity for such a
+         // document — it mirrors disk, and the AST is the only place the repair is
+         // legible, until an open consumes the staging.
          await this.documentBuilder.reparse(document, cancelToken);
       } else {
          // Linked-phase (or later) correction. The rule mutated the AST in place but
@@ -340,6 +354,26 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
          // stays in the builder, its proper home, rather than being duplicated here.
          await this.documentBuilder.reparseAndRelink(document, cancelToken);
       }
+
+      // Re-version against the REPAIRED text, after either branch. The repair is
+      // a content change the store has not seen: whatever reconciliation ran
+      // during the re-parse saw the text on disk, which in `'editor'` sync mode
+      // is the PRE-repair text. Leave the sequence describing that and the next
+      // open hashes the repair, finds a mismatch and steps the version again, so
+      // every `baseVersion` taken from this build is stale before it is used.
+      // Falls back to the pre-re-parse number for a URI the store never tracked,
+      // where there is no sequence to advance; an OPEN document answers
+      // `undefined` and keeps the store's own version, which is not this
+      // method's to move.
+      //
+      // Deliberately NOT gated on cancellation, unlike the entry to this method:
+      // `syncCorrections` has already written or staged the repair by now, so a
+      // preempted build that skipped this would leave the sequence describing
+      // text that is no longer there.
+      const reconciled = this.textDocuments.reconcileExternalContent(document.textDocument.uri, newText) ?? version;
+      if (document.textDocument.version !== reconciled) {
+         this.textDocuments.update(document.textDocument, [], reconciled);
+      }
    }
 
    /**

package/src/langium/model-service/model-service.ts

@@ -698,19 +698,29 @@ export class DefaultModelService<
       // created from the payload rather than read from the filesystem — `update`
       // is an upsert. For an already-open document `open` refreshes content (the
       // text is ignored on that branch), so existing-document behaviour is
-      // unchanged. `version` is intentionally NOT forwarded to `open`: a cold
-      // create stays at its initial version, so a based-on-`version` update of a
-      // not-yet-existing document still trips the conflict gate below.
+      // unchanged. `version` is intentionally NOT forwarded to `open`, so a cold
+      // create stays at its initial version rather than adopting a number the
+      // caller chose.
+      //
+      // The gate's version is read BEFORE that open, and must be: for a document
+      // no client holds open, the open assigns the shared version from the
+      // INCOMING text, so a version read afterwards has already absorbed the
+      // caller's own write. Gating on it rejected every modifying write to a
+      // closed document, having compared the caller's `baseVersion` against a
+      // number the caller itself produced — and a serialised round-trip that is
+      // not byte-identical to the stored text was enough to trigger it. Reading
+      // first keeps both cases the gate exists for: an unknown URI answers 0, so
+      // a based-on-version update of a not-yet-existing document still trips it,
+      // and a genuine conflict still trips it, another writer having advanced the
+      // sequence past the version the caller read.
+      const currentVersion = this.services.workspace.TextDocuments.version(uri);
       const text = await run('serialize', () => this.modelToText(uri, args.model, cancelToken));
       await run('open', () => this.open({ uri, clientId: args.clientId, text }));
-      if (args.baseVersion !== undefined) {
-         const current = this.services.workspace.TextDocuments.version(uri);
-         if (current !== args.baseVersion) {
-            // Distinct from the post-build "superseded" debug line below: this is a
-            // based-on-stale rejection (the write never applies), not two writes racing.
-            this.tracer.debug(`Conflict on ${uri}: based-on v${args.baseVersion} stale, server at v${current}`);
-            throw new ConflictError(uri, args.baseVersion, current);
-         }
+      if (args.baseVersion !== undefined && currentVersion !== args.baseVersion) {
+         // Distinct from the post-build "superseded" debug line below: this is a
+         // based-on-stale rejection (the write never applies), not two writes racing.
+         this.tracer.debug(`Conflict on ${uri}: based-on v${args.baseVersion} stale, server at v${currentVersion}`);
+         throw new ConflictError(uri, args.baseVersion, currentVersion);
       }
       const appliedVersion = await run('apply', () => this.services.workspace.AstDocumentManager.update(uri, text, args.clientId));
       // Dispatch through the public `rebuild` (which re-canonicalizes the already-

package/src/testing/stub-document-builder.ts

@@ -9,6 +9,7 @@
 
 import {
    type DocumentBuilder,
+   type DocumentBuildListener,
    type DocumentPhaseListener,
    type DocumentState,
    type DocumentUpdateListener,
@@ -94,6 +95,14 @@ export interface StubDocumentBuilder extends Pick<
    firePhase(state: DocumentState, document: LangiumDocument, cancelToken?: CancellationToken): void;
    /** Synchronously fire every registered `onUpdate` listener. */
    fireOnUpdate(changed: URI[], deleted: URI[]): void;
+   /**
+    * Synchronously fire the BUILD-phase listener(s) for `state` with the whole
+    * batch. The per-build counterpart of {@link firePhase}: a subject that
+    * reports once per build rather than once per document subscribes here, and
+    * a stub that only fired {@link firePhase} would leave it silent while
+    * looking wired.
+    */
+   fireBuildPhase(state: DocumentState, built: LangiumDocument[], cancelToken?: CancellationToken): void;
    /**
     * Hold the next {@link waitUntil} call. The returned handle releases it;
     * the call's return value resolves on the next tick after `resolve` runs.
@@ -131,6 +140,7 @@ function reraise(result: unknown): void {
  */
 export function makeStubDocumentBuilder(): StubDocumentBuilder {
    const phaseListeners = new Map<DocumentState, DocumentPhaseListener[]>();
+   const buildPhaseListeners = new Map<DocumentState, DocumentBuildListener[]>();
    const onUpdateListeners: DocumentUpdateListener[] = [];
    const gates: Array<{ take(release: () => void): void }> = [];
    const updateCalls: RecordedBuilderCall<[URI[], URI[]]>[] = [];
@@ -194,6 +204,28 @@ export function makeStubDocumentBuilder(): StubDocumentBuilder {
             reraise(listener(changed, deleted));
          }
       },
+      onBuildPhase(state: DocumentState, listener: DocumentBuildListener) {
+         const list = buildPhaseListeners.get(state) ?? [];
+         list.push(listener);
+         buildPhaseListeners.set(state, list);
+         return Disposable.create(() => {
+            const idx = list.indexOf(listener);
+            if (idx >= 0) {
+               list.splice(idx, 1);
+            }
+         });
+      },
+      fireBuildPhase(state: DocumentState, built: LangiumDocument[], cancelToken?: CancellationToken) {
+         const token =
+            cancelToken ??
+            ({
+               isCancellationRequested: false,
+               onCancellationRequested: () => Disposable.create(() => undefined)
+            } as CancellationToken);
+         for (const listener of buildPhaseListeners.get(state) ?? []) {
+            reraise(listener(built, token));
+         }
+      },
       gateNextWaitUntil(): StubWaitUntilGate {
          let release: (() => void) | undefined;
          const entry = {
@@ -224,9 +256,6 @@ export function makeStubDocumentBuilder(): StubDocumentBuilder {
       build() {
          return notSupported('build');
       },
-      onBuildPhase() {
-         return notSupported('onBuildPhase');
-      },
       resetToState() {
          return notSupported('resetToState');
       },