@hydranium/core 1.0.0-next.123 → 1.0.0-next.127

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

@@ -461,18 +461,14 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
     *   authority, and those heads read the correction from the settled build.
     *   In silent mode it is also written to disk when the text it was computed
     *   from is what disk holds, since the repair is then the only difference;
-    *   otherwise it waits for the next save. Editor mode always waits, and a
-    *   repair of text the holder never changed then differs from disk with
-    *   nothing marking it unsaved.
+    *   otherwise it waits for the next save. Editor mode always waits, and the
+    *   repair leaves the document dirty until a save.
     * - **Closed, silent mode** → write to disk directly (disk is authoritative).
     * - **Closed, editor mode** → stage so the next open picks it up via applyEdit.
     *
     * A held URI is not closed. Writing it as one persists the holder's unsaved
     * edits with the repair, and staging it leaves text no open reads, because
-    * only a first open consumes the stage. Leaving every held repair to a save
-    * is not enough either: a data or GLSP head marks only its own edits unsaved,
-    * so a repair of text it never changed would leave disk and store apart with
-    * nothing showing it.
+    * only a first open consumes the stage.
     *
     * `parsedFrom` is the text the repaired AST was parsed from. Without it a
     * held URI's repair is left to the next save.
@@ -548,6 +544,10 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
             this.tracer.with(document.uri).debug(`Held document unreadable on disk, repair left to the next save: ${String(error)}`);
             return;
          }
+         // The file itself, not the store's disk baseline: the baseline moves
+         // only when the server hears of a change, so it can still hold the
+         // parsed text after another process rewrote the file and before the
+         // watcher reports it, and this write would then replace that change.
          if (onDisk !== parsedFrom) {
             return;
          }
@@ -556,6 +556,7 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
             return;
          }
          await this.fileSystemProvider.writeFile(uri, repaired);
+         this.textDocuments.updateDiskBaseline(document.uri, repaired);
       });
    }
 

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

@@ -13,6 +13,7 @@ import {
    type MaybeObservableValue,
    type MaybePromise,
    ObservableValue,
+   TIMED_OUT,
    type TransferElement,
    type Tracer
 } from '@hydranium/protocol';
@@ -48,18 +49,9 @@ import { type ClientSession } from './client-session.js';
  */
 export const MODEL_UPDATE_EDIT = defineMessage('hydranium/core/model-update-edit', 'Update Model');
 
-/** Max time {@link ModelService.settleSave} waits for the build to settle and the sync chain to drain. */
+/** Max time {@link DefaultModelService.settleSave} waits for the build to settle and the sync chain to drain. */
 const SAVE_SETTLE_TIMEOUT_MS = 10_000;
 
-/**
- * Marks the {@link SAVE_SETTLE_TIMEOUT_MS} branch of
- * {@link ModelService.settleSave}'s race so it stays distinguishable from a
- * genuine rejection (a cancelled token, an `applyEdit` reverse-RPC error, a
- * build throw). With a plain `Error` the only log line an adopter has blames
- * the timeout for every one of them, which points debugging at the wrong layer.
- */
-class SaveSettleTimeoutError extends Error {}
-
 /**
  * Constructor options for {@link ModelService}. All fields are optional,
  * and the defaults are the behaviour described on each one.
@@ -672,8 +664,8 @@ export class DefaultModelService<
     * so every language client reflects the latest content before a save returns.
     * No-op tail for headless adopters — `syncChains` is empty without an LSP
     * client. Bounded by {@link SAVE_SETTLE_TIMEOUT_MS} so a hung build, or an
-    * applyEdit reverse-RPC deadlock, can't freeze the caller; on timeout it logs
-    * a warning and returns rather than throwing.
+    * applyEdit reverse-RPC deadlock, can't freeze the caller; on timeout or a
+    * failed wait it logs a warning and returns rather than throwing.
     *
     * Adopters with a save flow that must converge editor + disk before returning
     * (e.g. a dual form/code editor that would otherwise show a content-conflict
@@ -682,22 +674,21 @@ export class DefaultModelService<
    protected async settleSave(uri: string, cancelToken?: CancellationToken): Promise<void> {
       const canonical = this.uriPolicy.canonicalUri(uri);
       const key = UriUtils.toUri(canonical).toString();
-      const timeout = new Promise<void>((_, reject) =>
-         setTimeout(() => reject(new SaveSettleTimeoutError('settle timeout')), SAVE_SETTLE_TIMEOUT_MS)
-      );
+      // One race over both waits, so the bound is one deadline for the pair;
+      // a race per wait would let the save take twice the bound.
+      const settled = (async (): Promise<void> => {
+         await this.waitForDocumentStateCanonical(canonical, IntegrityService.SettledState, cancelToken);
+         await this.syncChains.get(key);
+      })();
       try {
-         await Promise.race([this.waitForDocumentStateCanonical(canonical, IntegrityService.SettledState, cancelToken), timeout]);
-         const pending = this.syncChains.get(key);
-         if (pending) {
-            await Promise.race([pending, timeout]);
-         }
-      } catch (err: unknown) {
-         if (err instanceof SaveSettleTimeoutError) {
+         if ((await this.services.Clock.raceTimer(settled, SAVE_SETTLE_TIMEOUT_MS)) === TIMED_OUT) {
             this.tracer.withUri(key).warn(`Save settle exceeded ${SAVE_SETTLE_TIMEOUT_MS}ms — returning anyway`);
-         } else {
-            const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
-            this.tracer.withUri(key).warn(`Save settle failed before the timeout — returning anyway. ${detail}`);
          }
+      } catch (err: unknown) {
+         // A failed wait, such as a cancelled token or a document the builder
+         // does not hold, gets its own line so it is not blamed on the bound.
+         const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+         this.tracer.withUri(key).warn(`Save settle failed before the timeout — returning anyway. ${detail}`);
       }
    }
 

package/src/lsp/hydranium-document-update-handler.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Debouncer, Deferred, type Logger, ObservableValue, type MaybeObservableValue } from '@hydranium/protocol';
+import { Debouncer, Deferred, type Logger, ObservableValue, type MaybeObservableValue, TIMED_OUT } from '@hydranium/protocol';
 import { URI, UriUtils } from '@hydranium/langium';
 import { DefaultDocumentUpdateHandler } from '@hydranium/langium/lsp';
 import { HYDRANIUM_BUILD_REASONS, type HydraniumDocumentBuilder } from '../langium/document-builder/document-builder.js';
@@ -212,6 +212,15 @@ export class HydraniumDocumentUpdateHandler extends DefaultDocumentUpdateHandler
             if (filtered.changes.length === 0) {
                return;
             }
+            // Only an open document keeps the file's text as its disk
+            // baseline; the store ignores the rest. The self-save filter has
+            // dropped the server's own writes, which set the baseline when
+            // they wrote.
+            for (const change of filtered.changes) {
+               this.textDocuments
+                  .reloadDiskBaseline(change.uri)
+                  .catch((err: unknown) => this.logger.error(`Disk baseline not reloaded for ${change.uri}. ${String(err)}`));
+            }
             // External file-system changes are authoritative — overwrite any
             // pending reason (typically empty here; could be `didChangeContent`
             // if a watcher event raced an in-flight Monaco edit, in which case
@@ -273,14 +282,12 @@ export class HydraniumDocumentUpdateHandler extends DefaultDocumentUpdateHandler
             void this.services.workspace.FileSystemTaskQueue.enqueue(uri, async () => {
                cap.dispose();
                resolve([]);
-               const bound = clock.setTimer(() => {
+               if ((await clock.raceTimer(hold.promise, this.willSaveGateMs)) === TIMED_OUT) {
                   this.logger.debug(
                      `No didSave for ${uri} within ${this.willSaveGateMs} ms; server writes of it no longer wait for the editor's save.`
                   );
                   release();
-               }, this.willSaveGateMs);
-               await hold.promise;
-               bound.dispose();
+               }
             });
          } catch (err) {
             cap.dispose();

package/src/node/socket-launcher.ts

@@ -7,9 +7,8 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Deferred } from '@hydranium/langium';
 import * as net from 'node:net';
-import type { Disposable, Logger } from '@hydranium/protocol';
+import { Deferred, type Disposable, type Logger } from '@hydranium/protocol';
 import { createMessageConnection, SocketMessageReader, SocketMessageWriter } from 'vscode-jsonrpc/node';
 import type { MessageConnection } from 'vscode-jsonrpc';
 import type { IntegratedServer } from '../launcher/integrated-server.js';

package/src/node/stdio-launcher.ts

@@ -7,8 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import { Deferred } from '@hydranium/langium';
-import type { Disposable, Logger } from '@hydranium/protocol';
+import { Deferred, type Disposable, type Logger } from '@hydranium/protocol';
 import type { MessageConnection } from 'vscode-jsonrpc';
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node';
 import type { IntegratedServer } from '../launcher/integrated-server.js';

package/src/testing/stub-hydranium-text-documents.ts

@@ -13,7 +13,12 @@ import { Disposable, Emitter } from 'vscode-languageserver';
 import type { TextDocument } from 'vscode-languageserver-textdocument';
 import { LANGUAGE_CLIENT_ID } from '../documents/client-ids.js';
 import { ClientSessionRegistry } from '../documents/client-session-registry.js';
-import type { ClientTextDocumentChangeEvent, HydraniumTextDocuments, LastOpenClosedEvent } from '../documents/hydranium-text-documents.js';
+import type {
+   ClientTextDocumentChangeEvent,
+   DocumentDirtyChangedEvent,
+   HydraniumTextDocuments,
+   LastOpenClosedEvent
+} from '../documents/hydranium-text-documents.js';
 
 /** Snapshot of an open document tracked by the stub. */
 export interface StubTextDocumentEntry {
@@ -31,7 +36,9 @@ export interface StubTextDocumentEntry {
  * `isOpenInAnyClient` / `isOpenInClient` / `isRevertPending` /
  * `openDocuments`), the push channel
  * to the language client (`applyEditToLanguageClient` / `stagePendingContent`),
- * the save / close notifications, and the client-session table
+ * the save / close notifications, the dirty state (`isDirty` /
+ * `onDidChangeDirty` / `updateDiskBaseline`, against a baseline {@link seedOpen}
+ * sets and a save that carries its text moves), and the client-session table
  * (`registerSession` / `closeSession` / `onDidCloseSession`), which is a real
  * `ClientSessionRegistry` — plus test-only helpers:
  *
@@ -80,6 +87,9 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'closeSession'
    | 'onDidCloseSession'
    | 'onDidCloseLastOpen'
+   | 'isDirty'
+   | 'onDidChangeDirty'
+   | 'updateDiskBaseline'
 > {
    /**
     * Stub-tailored read accessor. Returns just the surface the framework's
@@ -98,7 +108,7 @@ export interface StubHydraniumTextDocuments extends Pick<
    onDidSave(listener: (event: { document: { uri: string }; clientId: string }) => void): Disposable;
    /** Real-shaped close subscription — listener gets {@link ClientTextDocumentChangeEvent}. */
    onDidClose(listener: (event: ClientTextDocumentChangeEvent<TextDocument>) => void): Disposable;
-   /** Pre-populate an open document without firing change events. */
+   /** Pre-populate an open document without firing change events; `text` is also its disk baseline. */
    seedOpen(uri: string, text: string, clientId: string): void;
    /** Mark `uri` as open in the LSP textual language client (drives {@link isOpenInLanguageClient}). */
    seedOpenInLanguageClient(uri: string): void;
@@ -152,6 +162,23 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
    const sessions = new ClientSessionRegistry();
    const key = (uri: string): CanonicalUri => uri as CanonicalUri;
    const lastOpenClosed = new Emitter<LastOpenClosedEvent>();
+   const baselines = new Map<string, string | undefined>();
+   const dirty = new Set<string>();
+   const dirtyChanged = new Emitter<DocumentDirtyChangedEvent>();
+   // As the real store: dirty while held with text other than the baseline,
+   // announced only when the answer changes.
+   const refreshDirty = (uri: string): void => {
+      const held = docs.get(uri);
+      const now = held !== undefined && held.text !== baselines.get(uri);
+      if (now !== dirty.has(uri)) {
+         if (now) {
+            dirty.add(uri);
+         } else {
+            dirty.delete(uri);
+         }
+         dirtyChanged.fire({ uri: key(uri), dirty: now });
+      }
+   };
 
    const stub: StubHydraniumTextDocuments = {
       get changes() {
@@ -186,6 +213,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          }
          docs.set(event.textDocument.uri, next);
          changes.push(next);
+         refreshDirty(event.textDocument.uri);
       },
       applyContentChange(uri, text, clientId) {
          const existing = docs.get(uri);
@@ -199,9 +227,13 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          const next: StubTextDocumentEntry = changed ? { uri, version: existing.version + 1, text, clientId } : existing;
          docs.set(uri, next);
          changes.push({ uri, version: next.version, text, clientId });
+         refreshDirty(uri);
          return next.version;
       },
       notifyDidSaveTextDocument(event, clientId) {
+         if (event.text !== undefined) {
+            stub.updateDiskBaseline(event.textDocument.uri, event.text);
+         }
          saves.push({ uri: event.textDocument.uri, clientId });
          for (const listener of saveListeners.slice()) {
             listener({ document: { uri: event.textDocument.uri }, clientId });
@@ -264,6 +296,18 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       get onDidCloseLastOpen() {
          return lastOpenClosed.event;
       },
+      isDirty(uri) {
+         return dirty.has(uri);
+      },
+      get onDidChangeDirty() {
+         return dirtyChanged.event;
+      },
+      updateDiskBaseline(uri, text) {
+         if (docs.has(uri)) {
+            baselines.set(uri, text);
+            refreshDirty(uri);
+         }
+      },
       openDocuments() {
          // From the registry that also answers `isOpenInClient`, which both
          // seeding channels feed, so the two never disagree about an open.
@@ -282,6 +326,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       seedOpen(uri, text, clientId) {
          sessions.addOpen(key(uri), clientId);
          docs.set(uri, { uri, version: 1, text, clientId });
+         baselines.set(uri, text);
       },
       seedOpenInLanguageClient(uri) {
          sessions.addOpen(key(uri), LANGUAGE_CLIENT_ID);
@@ -294,6 +339,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          const holder = docs.get(uri);
          if (holder && holder.clientId === clientId) {
             docs.delete(uri);
+            refreshDirty(uri);
          }
          const removed = sessions.removeOpen(key(uri), clientId);
          if (clientId === LANGUAGE_CLIENT_ID) {
@@ -314,6 +360,8 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          languageClientOpen.clear();
          appliedEdits.length = 0;
          staged.length = 0;
+         baselines.clear();
+         dirty.clear();
          saveListeners.length = 0;
          closeListeners.length = 0;
          applyEditHandler = () => ({ applied: true });