@hydranium/core 1.0.0-next.206 → 1.0.0-next.209

package/src/documents/document-release-handler.ts

@@ -67,7 +67,7 @@ export function isDocumentReleaseSkippedError(error: unknown): error is Document
  *
  * The data server announces the first build of a released document as the
  * release, so a handler that builds nothing leaves that to whichever build
- * comes next, a client's edit included.
+ * comes next; one that carries a client's write keeps that client's name.
  *
  * Extend {@link DefaultDocumentReleaseHandler} to change only the policy: it
  * keeps the locking and the wait for the build. An implementation written
@@ -142,6 +142,7 @@ export class DefaultDocumentReleaseHandler implements DocumentReleaseHandler {
    async didReleaseDocument(released: ReleasedDocument): Promise<void> {
       const target = UriUtils.toUri(released.uri);
       const outcome = await this.runRelease(released, target);
+      this.tracer.with(released.uri).debug(`Release outcome: ${this.formatReleaseOutcome(outcome)}`);
       if (outcome.kind === 'skipped') {
          if (!outcome.parsed) {
             throw new DocumentReleaseSkippedError(outcome.error);
@@ -243,6 +244,19 @@ export class DefaultDocumentReleaseHandler implements DocumentReleaseHandler {
       }
    }
 
+   /**
+    * `outcome` for the line each release logs at debug: its kind, the
+    * decision and whether the document was parsed.
+    */
+   protected formatReleaseOutcome(outcome: DocumentReleaseOutcome): string {
+      if (outcome.kind === 'reclaimed') {
+         return 'reclaimed by a client, built nothing';
+      }
+      const decision = 'decision' in outcome && outcome.decision !== undefined ? ` ${outcome.decision}` : '';
+      const parsed = 'parsed' in outcome ? (outcome.parsed ? ', parsed' : ', not parsed') : '';
+      return `${outcome.kind}${decision}${parsed}`;
+   }
+
    /**
     * The policy: rebuild a document the file system provider can serve, and
     * remove any other. Read in the document's disk queue, so it follows any

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

@@ -203,6 +203,9 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
     */
    protected readonly __sessions = new ClientSessionRegistry();
 
+   /** The version each open document was opened at; see {@link openedVersion}. */
+   protected readonly __openedVersions = new Map<CanonicalUri, TextVersion>();
+
    protected readonly tracer: Tracer;
    protected readonly configuration: TextDocumentsConfiguration<T>;
    protected __textLedger: TextLedger | undefined;
@@ -598,6 +601,7 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
       this.textLedger.clearAuthors(uri);
       const cleanAnnouncement = this.dirtyStateTracker.release(uri);
       this.__syncedDocuments.delete(uri);
+      this.__openedVersions.delete(uri);
       this.__sessions.forgetClientVersions(uri);
       // A stage is for a first open; one released unconsumed is stale.
       this.__pendingContent.delete(uri);
@@ -787,6 +791,7 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
          this.log(uri, `Open document: Version ${version} by ${this.formatClientId(clientId)} [first client${source}]`);
          document = this.create(uri, td.languageId, version, text);
          this.commitText(uri, document, clientId);
+         this.__openedVersions.set(uri, version);
          // The opener's text, not the staged content: a session's open read
          // it from the file, and an editor opened its buffer from there. An
          // editor that opens a buffer it never saved is taken as clean.
@@ -922,6 +927,14 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
       return this.get(uri)?.version ?? this.textLedger.recordOf(this.documentKey(uri))?.version ?? 0;
    }
 
+   /**
+    * The version the document at `uri` was opened at, which a client's write
+    * or an integrity repair steps past; `undefined` while it is not open.
+    */
+   openedVersion(uri: DocumentUri): TextVersion | undefined {
+      return this.__openedVersions.get(this.documentKey(uri));
+   }
+
    /**
     * The text the store holds for `uri`: an open document's, or for a closed
     * one, the clean text its version sequence left off at, which for a deleted
@@ -1319,17 +1332,16 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
    /**
     * Stages integrity-updated content for a document no client holds.
     *
-    * When `workspace/applyEdit` targets a closed file, the client opens it from
-    * disk (stale) and sends `didOpen` before applying the edit. This staged
-    * content is consumed by {@link notifyDidOpenTextDocument} to replace the
-    * stale disk text, preventing a brief revert of the integrity update.
+    * Nothing is pushed to a file no client holds. The next open of it reads
+    * disk, which lacks the update; {@link notifyDidOpenTextDocument} takes this
+    * staged content in place of that text, and the open's sync then delivers
+    * it to an editor as an unsaved change.
     *
     * Only a FIRST open consumes it, so stage only for a URI no client holds
     * ({@link isOpenInAnyClient} is `false`). A URI held only through another
     * head is not closed: an editor attaching to it joins the existing entry and
-    * never reads the stage, and the release discards it. An entry lingers
-    * only if `workspace/applyEdit` fails and the file is never opened — the
-    * memory cost is one serialised string per URI.
+    * never reads the stage, and the release discards it. An entry waits for
+    * that first open, at one serialised string per URI.
     */
    stagePendingContent(uri: DocumentUri, text: string): void {
       this.__pendingContent.set(this.documentKey(uri), text);
@@ -1344,6 +1356,9 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
     *   - The shared services have no LSP {@link Connection} bound (non-LSP
     *     hosts like CLI / tests).
     *   - The shadow already matches `newText` (no edits needed; quiet skip).
+    *   - The language client has not opened the document. A client applies an
+    *     edit to a closed file by opening it, and that open races the edit;
+    *     the document's own open delivers its text instead.
     *
     * On `applyEdit` rejection (`result.applied === false`) or RPC failure the
     * shadow is invalidated so the next call sends a full-replace baseline.
@@ -1381,7 +1396,7 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
       // under each URI it opened, and each is diffed against its own baseline.
       const key = this.documentKey(uri);
       let lastResult: ApplyWorkspaceEditResult | undefined;
-      for (const clientUri of this.languageClientShadow.pushTargets(key, this.toLanguageClientUri(uri))) {
+      for (const clientUri of this.languageClientShadow.pushTargets(key)) {
          // Prepared per target, after the previous target's reply: prepared up
          // front, a later target is diffed against what it held before a change
          // that arrived meanwhile.
@@ -1421,10 +1436,13 @@ export class HydraniumTextDocuments<T extends TextDocument = TextDocument> exten
    }
 
    /**
-    * Explicitly baseline the language-client shadow for a URI. Useful in
-    * tests and for adopters that need to seed the shadow without going through
-    * a `didOpen` event (e.g. after a sideband save). Normal didOpen / didChange
-    * paths from the LSP language client already auto-track the shadow.
+    * Explicitly baseline the language-client shadow for a URI the client has
+    * open, for an adopter that knows what the client holds without a
+    * `didChange` saying so (e.g. after a sideband save). Normal didOpen /
+    * didChange paths from the LSP language client already auto-track the
+    * shadow. A seed for a URI the client has not opened is kept but changes no
+    * push, since nothing is pushed there; its open replaces it with the text it
+    * declares.
     */
    setLanguageClientText(uri: DocumentUri, text: string): void {
       this.languageClientShadow.setClientText(this.toLanguageClientUri(uri), text);

package/src/documents/language-client-shadow.ts

@@ -47,10 +47,10 @@ export interface PendingLanguageClientPush {
     * and applied to the already-advanced synced text the line they insert
     * lands twice.
     *
-    * `undefined` only when that buffer is unknown — the client never declared
-    * one, or a rejection invalidated what was tracked. The echo is then
-    * reconstructed against the synced text, which is sound only for a
-    * position-independent (full-text) change.
+    * `undefined` only when that buffer is unknown, because a rejection or
+    * {@link LanguageClientShadow.invalidateClientText} dropped what was
+    * tracked. The echo is then reconstructed against the synced text, which
+    * is sound only for a position-independent (full-text) change.
     */
    readonly before: string | undefined;
    /** {@link textHash} of the text this push moves the client to. */
@@ -97,7 +97,7 @@ export type LanguageClientChangeVerdict =
 
 /**
  * The store's model of what the LSP language client holds for each URI it
- * opened or the store pushed to: the text, the version it declared and the version a push moved it
+ * opened: the text, the version it declared and the version a push moved it
  * to, and the pushes it has not echoed yet. The store speaks the protocol;
  * this answers what an incoming change is and what an outgoing push sends.
  *
@@ -112,10 +112,10 @@ export type LanguageClientChangeVerdict =
 export interface LanguageClientShadow {
    /**
     * The client opened `key` under `clientUri`. `firstOpen`, the store's first
-    * open of `key`: its text becomes the diff baseline, unless a push already
-    * waits for this URI; otherwise an equality-only baseline, since a buffer
-    * opened from disk can lag the synced text. A no-op when this URI is
-    * already open.
+    * open of `key`: its text becomes the diff baseline; otherwise an
+    * equality-only baseline, since a buffer opened from disk can lag the
+    * synced text. Either replaces what was tracked for `clientUri` before the
+    * open. A no-op when this URI is already open.
     */
    addOpen(key: CanonicalUri, clientUri: LanguageClientUri, version: number, text: string, firstOpen: boolean): void;
    /** The version the client last declared for `key` under `clientUri`; `undefined` when it never opened it there. */
@@ -140,12 +140,18 @@ export interface LanguageClientShadow {
    isOpen(key: CanonicalUri, clientUri?: LanguageClientUri): boolean;
    /** Forget every URI the client holds `key` under. */
    removeAllOpens(key: CanonicalUri): void;
-   /** The URIs a push of `key` goes to: each open of it, else `fallback`. */
-   pushTargets(key: CanonicalUri, fallback: LanguageClientUri): LanguageClientUri[];
+   /**
+    * The URIs a push of `key` goes to: each open of it, none when the client
+    * has not opened it. A client applies a push to a closed file by opening
+    * it, and an open racing its own push leaves no text to diff against.
+    */
+   pushTargets(key: CanonicalUri): LanguageClientUri[];
    /**
     * Diff `text` against what the client holds under `clientUri` and queue the
     * push for echo correlation, which has to precede the RPC because an echo
-    * can arrive before its response. `undefined` when there is nothing to send.
+    * can arrive before its response. `undefined` when there is nothing to send,
+    * which includes a `clientUri` the client no longer has open: a close can
+    * land while the push to another of its URIs is in flight.
     */
    preparePush(key: CanonicalUri, clientUri: LanguageClientUri, text: string): PreparedLanguageClientPush | undefined;
    /** Forget what the client holds under `clientUri`; its next push is a full replace. */
@@ -209,12 +215,13 @@ export class DefaultLanguageClientShadow<T extends TextDocument = TextDocument>
          this.opens.set(key, uris);
       }
       uris.set(clientUri, { declaredVersion: version });
-      if (!firstOpen) {
-         this.openedTexts.set(clientUri, text);
-      } else if (!this.baselines.has(clientUri)) {
-         // A push to a closed file has the client open it from disk and apply
-         // afterwards, so a tracked text already names what it is about to hold.
+      // Dropped: a seed set before the open names no buffer, and a line diff
+      // against it splices text the client does not hold.
+      this.invalidateClientText(clientUri);
+      if (firstOpen) {
          this.baselines.set(clientUri, text);
+      } else {
+         this.openedTexts.set(clientUri, text);
       }
    }
 
@@ -312,12 +319,16 @@ export class DefaultLanguageClientShadow<T extends TextDocument = TextDocument>
       this.opens.delete(key);
    }
 
-   pushTargets(key: CanonicalUri, fallback: LanguageClientUri): LanguageClientUri[] {
-      const uris = this.opens.get(key);
-      return uris && uris.size > 0 ? [...uris.keys()] : [fallback];
+   pushTargets(key: CanonicalUri): LanguageClientUri[] {
+      return [...(this.opens.get(key)?.keys() ?? [])];
    }
 
    preparePush(key: CanonicalUri, clientUri: LanguageClientUri, text: string): PreparedLanguageClientPush | undefined {
+      // Captured now: a reopen while the push is in flight replaces the state.
+      const state = this.opens.get(key)?.get(clientUri);
+      if (state === undefined) {
+         return undefined;
+      }
       // Read before computing the edits, which moves the baseline: this is the
       // only text the push's echo can be reconstructed against.
       const before = this.clientText(clientUri);
@@ -326,12 +337,9 @@ export class DefaultLanguageClientShadow<T extends TextDocument = TextDocument>
          return undefined;
       }
       this.recordPendingPush(clientUri, before, text);
-      // Captured now: a reopen while the push is in flight replaces the state.
-      const state = this.opens.get(key)?.get(clientUri);
       // Gating a full replace turns a stale-by-one version into a refused
       // update for no safety gain, and refuses the retry after a rejection.
-      const version =
-         isFullReplace(edits) || state === undefined ? null : Math.max(state.declaredVersion, state.pushedVersion ?? state.declaredVersion);
+      const version = isFullReplace(edits) ? null : Math.max(state.declaredVersion, state.pushedVersion ?? state.declaredVersion);
       let settled = false;
       return {
          clientUri,
@@ -344,7 +352,7 @@ export class DefaultLanguageClientShadow<T extends TextDocument = TextDocument>
                   this.tracer
                      .with(key)
                      .warn(
-                        `Language client refused applyEdit addressed at version ${version} (it last declared version ${state?.declaredVersion})`
+                        `Language client refused applyEdit addressed at version ${version} (it last declared version ${state.declaredVersion})`
                      );
                }
                this.settle(clientUri, version, state, outcome);

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

@@ -59,12 +59,12 @@ export namespace IntegrityPhase {
  *    correction. Otherwise — the holder has unsaved edits, disk changed behind
  *    the server, or disk cannot be read — the correction waits in the text
  *    store for the next save.
- * - `editor`: open the file dirty via `applyEdit`. If the user closes without
- *    saving, the correction is suppressed until the file changes or the
- *    workspace reloads. A file held only through the data or GLSP head gets
- *    neither: the correction stays in the text store, and since those heads
- *    mark only their own edits unsaved, nothing shows that store and disk
- *    differ until a save or the last close.
+ * - `editor`: leave disk alone and stage the correction; the next open of the
+ *    file takes it over the disk text, and an editor shows it as an unsaved
+ *    change. Until then no editor sees it. A file held only through the data
+ *    or GLSP head is not staged: the correction stays in the text store, and
+ *    since those heads mark only their own edits unsaved, nothing shows that
+ *    store and disk differ until a save or the last close.
  */
 export type IntegritySyncMode = 'silent' | 'editor';
 

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

@@ -469,7 +469,8 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
     *   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.
+    * - **Closed, editor mode** → stage, so the next open takes the correction
+    *   over the disk text.
     *
     * 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
@@ -520,7 +521,7 @@ export class DefaultIntegrityService<TRoot extends AstNode = AstNode> implements
          return;
       }
 
-      // Closed files, editor mode: stage content so the next open picks it up via applyEdit.
+      // Closed files, editor mode: stage content for the next open.
       this.textDocuments.stagePendingContent(document.uri, document.getText());
    }
 

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

@@ -262,6 +262,11 @@ export interface ModelService<
    validated(uri: string, cancelToken?: CancellationToken): Promise<AstDocument<TAst, TDiagnostic>>;
 
    isOpen(uri: string): boolean;
+   /**
+    * The version the document at `uri` was opened at, which a client's write
+    * or an integrity repair steps past; `undefined` while it is not open.
+    */
+   openedVersion(uri: string): TextVersion | undefined;
    snapshot(uri: string): AstDocument<TAst, TDiagnostic> | undefined;
    /**
     * The text a session's write of `model` to `uri` applies: a textual model
@@ -839,6 +844,10 @@ export class DefaultModelService<
       return this.services.workspace.AstDocumentManager.isOpen(uri);
    }
 
+   openedVersion(uri: string): TextVersion | undefined {
+      return this.services.workspace.TextDocuments.openedVersion(uri);
+   }
+
    /**
     * Snapshot of `uri` as it stands RIGHT NOW — the synchronous sibling of the
     * phase reads, which all wait. `undefined` when no document is registered,

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

@@ -89,6 +89,7 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'onDidReleaseDocument'
    | 'isDirty'
    | 'textState'
+   | 'openedVersion'
    | 'onDidChangeDirty'
    | 'setDiskBaseline'
 > {
@@ -135,15 +136,20 @@ export interface StubHydraniumTextDocuments extends Pick<
    /**
     * Decide what {@link applyEditToLanguageClient} answers, so a suite can drive
     * the rejection path (`{ applied: false }`) the real client takes when its
-    * buffer has outrun the version the push was addressed at. The call is still
-    * recorded in {@link appliedEdits} either way. Defaults to accepting.
+    * buffer has outrun the version the push was addressed at. The push is still
+    * recorded in {@link appliedEdits} either way. Defaults to accepting; not
+    * called for a URI not open in the language client.
     *
     * The handler runs INSIDE the call, which is also the only place a suite can
     * simulate something happening while the push is in flight — a newer settle,
     * a concurrent client edit.
     */
    setApplyEditHandler(handler: (uri: string, text: string) => ApplyWorkspaceEditResult | undefined): void;
-   /** Replay of every {@link applyEditToLanguageClient} call (the text channel to Monaco). */
+   /**
+    * Replay of every push {@link applyEditToLanguageClient} sent (the text
+    * channel to Monaco): none for a URI not seeded open in the language client,
+    * as the real store sends none.
+    */
    readonly appliedEdits: readonly { uri: string; text: string; label?: string }[];
    /** Replay of every {@link stagePendingContent} call (the not-yet-open staging path). */
    readonly staged: readonly { uri: string; text: string }[];
@@ -167,6 +173,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
    const key = (uri: string): CanonicalUri => uri as CanonicalUri;
    const documentReleased = new Emitter<DocumentReleasedEvent>();
    const baselines = new Map<string, string | undefined>();
+   const openedVersions = new Map<string, number>();
    const dirty = new Set<string>();
    const dirtyChanged = new Emitter<DocumentDirtyChangedEvent>();
    // As the real store: dirty while held with text other than the baseline,
@@ -209,6 +216,9 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       version(uri) {
          return docs.get(uri)?.version ?? 0;
       },
+      openedVersion(uri) {
+         return docs.has(uri) ? openedVersions.get(uri) : undefined;
+      },
       textState(uri) {
          const held = docs.get(uri);
          return held && { version: held.version, hash: textHash(held.text), dirty: dirty.has(uri) };
@@ -331,6 +341,9 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          applyEditHandler = handler;
       },
       async applyEditToLanguageClient(uri, newText, options): Promise<ApplyWorkspaceEditResult | undefined> {
+         if (!languageClientOpen.has(uri)) {
+            return undefined;
+         }
          appliedEdits.push({ uri, text: newText, label: options?.label });
          return applyEditHandler(uri, newText);
       },
@@ -340,6 +353,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       seedOpen(uri, text, clientId) {
          sessions.addOpen(key(uri), clientId);
          docs.set(uri, { uri, version: 1, text, clientId });
+         openedVersions.set(uri, 1);
          baselines.set(uri, text);
       },
       seedOpenInLanguageClient(uri) {
@@ -379,6 +393,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          appliedEdits.length = 0;
          staged.length = 0;
          baselines.clear();
+         openedVersions.clear();
          dirty.clear();
          saveListeners.length = 0;
          closeListeners.length = 0;