@hydranium/core 1.0.0-next.271 → 1.0.0-next.273

package/src/langium/workspace/persistent-file-system-provider.ts

@@ -167,7 +167,7 @@ export class PersistentFileSystemProvider extends InMemoryFileSystemProvider {
          // insertion order of a merged record.
          const uri = this.storeUri(path);
          if (content === TOMBSTONE) {
-            super.deleteFile(uri);
+            this.files.delete(this.fileKey(uri));
          } else {
             super.setFile(uri, content);
          }
@@ -202,9 +202,16 @@ export class PersistentFileSystemProvider extends InMemoryFileSystemProvider {
       await this.persist(uri, content);
    }
 
-   override deleteFile(uri: URI): void {
-      super.deleteFile(uri);
-      this.forget(uri).catch((error: unknown) => this.reportStoreFailure('forget', uri, error));
+   /**
+    * Mirror the deletion into the store and REJECT if it refuses, as
+    * {@link writeFile} does. The store goes first, so one that refuses leaves
+    * the file it still holds; a directory is refused before the store is asked.
+    */
+   override async deleteFile(uri: URI): Promise<void> {
+      if (!this.hasChildren(this.fileKey(uri))) {
+         await this.forget(uri);
+      }
+      await super.deleteFile(uri);
    }
 
    /** The absolute URI a store-space `path` addresses. */
@@ -245,7 +252,7 @@ export class PersistentFileSystemProvider extends InMemoryFileSystemProvider {
          return key;
       }
       if (!key.startsWith(this.storeRoot)) {
-         throw new Error(`Cannot persist ${uri.toString()}: outside the store root ${this.storeRoot}`);
+         throw new Error(`${uri.toString()} is outside the store root ${this.storeRoot}`);
       }
       return key.slice(this.storeRoot.length);
    }

package/src/langium/workspace/virtual-document.ts

@@ -12,7 +12,7 @@ import { type Tracer } from '@hydranium/protocol';
 import { type WritableFileSystemProvider } from './file-system-provider.js';
 import { type LogNameOptions } from '../diagnostics/logger.js';
 import { type ServerSharedServicesMinimal } from '../shared-services.js';
-import { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_WRITE } from './in-memory-file-system-provider.js';
+import { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_DELETE, UNSUPPORTED_WRITE } from './in-memory-file-system-provider.js';
 import { notFound } from './file-not-found.js';
 
 /**
@@ -95,7 +95,7 @@ export function isVirtualUri(uri: URI | string): boolean {
  * always a FILE with no children: a workspace walk handed a directory would try
  * to enumerate children it has none of.
  *
- * Read-only: a write is refused, since nothing backs the scheme.
+ * Read-only: a write or delete is refused, since nothing backs the scheme.
  */
 export class VirtualFileSystemProvider implements WritableFileSystemProvider {
    protected readonly tracer: Tracer;
@@ -111,6 +111,10 @@ export class VirtualFileSystemProvider implements WritableFileSystemProvider {
       throw new Error(UNSUPPORTED_WRITE.format({ uri: uri.toString() }));
    }
 
+   async deleteFile(uri: URI): Promise<void> {
+      throw new Error(UNSUPPORTED_DELETE.format({ uri: uri.toString() }));
+   }
+
    async readFile(uri: URI): Promise<string> {
       return this.readFileSync(uri);
    }

package/src/langium/workspace/write-lock-scope.ts

@@ -79,22 +79,24 @@ export function isWriteLockScopeInstalled(): boolean {
 /**
  * Thrown when the model facade is reached from inside a workspace write-lock
  * holder — typically an integrity rule or build-phase pass writing through
- * a session's `update` / `save` or `ModelService.rebuild` during a build.
+ * a session's `update` / `save` / `delete` or `ModelService.rebuild` during a
+ * build.
  *
  * Named rather than a bare `Error` because the remedy is specific and worth
  * pointing at: either move the write out of the build (integrity rules that
  * persist repairs should write through `FileSystemProvider.writeFile`, which
  * takes no lock), or set `ModelServiceOptions.allowReentrantBuilds: true`,
  * which keeps the facade's build from cancelling the holder but not its wait
- * from stalling on a document that needs a re-queue.
+ * from stalling on a document that needs a re-queue. A delete is refused on
+ * either value.
  */
 export class ReentrantWriteLockError extends Error {
    constructor(readonly uri: string) {
       super(
          `Model facade reached for '${uri}' from inside a workspace write-lock holder. ` +
             'Acquiring the write lock would cancel the enclosing build and may stall this call. ' +
-            'Write through FileSystemProvider.writeFile from a build-phase pass, or set ' +
-            'ModelServiceOptions.allowReentrantBuilds: true to build without the lock from inside it.'
+            'Write through FileSystemProvider.writeFile from a build-phase pass, or, for an update, save or rebuild, ' +
+            'set ModelServiceOptions.allowReentrantBuilds: true to build without the lock from inside it.'
       );
       this.name = 'ReentrantWriteLockError';
    }

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

@@ -80,7 +80,8 @@ export interface HydraniumDocumentUpdateHandlerOptions {
  *
  *  1. **Self-save filter** ({@link filterSelfSaves}) — drops
  *     watched-file-change echoes for the server's own writes via
- *     {@link SelfSaveRegistry}, keyed by `fsPath` + mtime.
+ *     {@link SelfSaveRegistry}, keyed by `fsPath` + mtime, and
+ *     ({@link filterStaleDeletions}) deletions the disk contradicts.
  *  2. **Trailing-edge debouncing** — collapses rapid
  *     `didChangeContent` calls into one rebuild on the trailing
  *     edge of the configured window. Non-language-client author
@@ -218,6 +219,7 @@ export class HydraniumDocumentUpdateHandler extends DefaultDocumentUpdateHandler
 
    override didChangeWatchedFiles(params: DidChangeWatchedFilesParams): void {
       void this.filterSelfSaves(params)
+         .then(unsaved => this.filterStaleDeletions(unsaved))
          .then(filtered => {
             if (filtered.changes.length === 0) {
                return;
@@ -348,6 +350,33 @@ export class HydraniumDocumentUpdateHandler extends DefaultDocumentUpdateHandler
       return { changes: kept.filter((change): change is FileEvent => change !== undefined) };
    }
 
+   /**
+    * Drop a deletion the disk contradicts: the file is there, or the document
+    * at the URI was created from a session's text and its file not seen since,
+    * as one created again after a delete. A watcher reports a delete late, the
+    * server's own included, and applied to a document created again since, it
+    * would close every open of it. A missing disk baseline cannot stand in for
+    * the creation: a report that finds the file gone clears it too. A record
+    * of the server's own unlinks could not tell its echo from a later real
+    * delete, since a delete leaves no mtime to match. A miss the provider
+    * reports in error keeps the deletion.
+    */
+   protected async filterStaleDeletions(params: DidChangeWatchedFilesParams): Promise<DidChangeWatchedFilesParams> {
+      const kept = await Promise.all(
+         params.changes.map(async change => {
+            if (change.type !== FileChangeType.Deleted) {
+               return change;
+            }
+            if (this.textDocuments.isUnsavedCreation(change.uri)) {
+               return undefined;
+            }
+            const exists = await this.fileSystemProvider.exists(UriUtils.toUri(change.uri)).catch(() => false);
+            return exists ? undefined : change;
+         })
+      );
+      return { changes: kept.filter((change): change is FileEvent => change !== undefined) };
+   }
+
    /**
     * Coalesce `changed` / `deleted` into the pending sets, then either
     * flush immediately (`immediateFlush` or `debounceMs <= 0`) or restart

package/src/messages/index.ts

@@ -33,4 +33,4 @@ export {
    UNRESOLVED_REFERENCE
 } from '../langium/validation/document-validator.js';
 export { NO_LOADABLE_CONTENT } from '../langium/workspace/langium-documents.js';
-export { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_WRITE } from '../langium/workspace/in-memory-file-system-provider.js';
+export { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_DELETE, UNSUPPORTED_WRITE } from '../langium/workspace/in-memory-file-system-provider.js';

package/src/node/node-file-system-provider.ts

@@ -14,11 +14,12 @@ import { randomUUID } from 'node:crypto';
 import { realpathSync } from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import { type WritableFileSystemProvider } from '../langium/workspace/file-system-provider.js';
+import { isFileNotFound } from '../langium/workspace/file-not-found.js';
 import { type SelfSaveRegistry } from '../langium/workspace/self-save-registry.js';
 import { RENAME_GAP_BUDGET_MS, renameOverOpenReaders } from './rename-over-open-readers.js';
 import { type LogNameOptions } from '../langium/diagnostics/logger.js';
 import { serverSharedFactory, type ServerSharedServicesMinimal } from '../langium/shared-services.js';
-import { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_WRITE } from '../langium/workspace/in-memory-file-system-provider.js';
+import { NO_SUCH_FILE, NO_SUCH_PATH, UNSUPPORTED_DELETE, UNSUPPORTED_WRITE } from '../langium/workspace/in-memory-file-system-provider.js';
 
 /**
  * Node-based default {@link WritableFileSystemProvider}. Extends Langium's
@@ -252,6 +253,26 @@ export class DefaultFileSystemProvider extends NodeFileSystemProvider implements
       }
    }
 
+   /**
+    * Unlink `uri`, which removes a symlink rather than the file it points at
+    * and leaves a parent directory it empties in place. A file already gone is
+    * no error; a directory is refused, as `unlink` refuses it.
+    */
+   async deleteFile(uri: URI): Promise<void> {
+      // Before the path is derived, for the reason `writeFile` gives: `fsPath`
+      // would name an unrelated file for a URI naming no disk location.
+      if (!this.servesFromDisk(uri)) {
+         throw new Error(UNSUPPORTED_DELETE.format({ uri: uri.toString() }));
+      }
+      try {
+         await fsp.unlink(uri.fsPath);
+      } catch (error: unknown) {
+         if (!isFileNotFound(error, uri)) {
+            throw error;
+         }
+      }
+   }
+
    async mtimeMs(uri: URI): Promise<number | undefined> {
       // Same rule as the read surface, and "unknown" is already the answer the
       // caller handles — so a URI naming no disk location reports no mtime

package/src/testing/stub-ast-document-manager.ts

@@ -41,7 +41,18 @@ import type { StubLangiumDocuments } from './stub-langium-documents.js';
  */
 export interface StubAstDocumentManager<TAst extends AstNode, TDiagnostic extends AstDiagnostic = AstDiagnostic> extends Pick<
    AstDocumentManager<TAst, TDiagnostic>,
-   'open' | 'close' | 'isOpen' | 'update' | 'save' | 'getAuthor' | 'getDocument' | 'toAstDocument' | 'attributeUpdate'
+   | 'open'
+   | 'close'
+   | 'isOpen'
+   | 'update'
+   | 'save'
+   | 'delete'
+   | 'isDeleting'
+   | 'attributeDeletion'
+   | 'getAuthor'
+   | 'getDocument'
+   | 'toAstDocument'
+   | 'attributeUpdate'
 > {
    readonly openClients: Map<string, Set<string>>;
 }
@@ -96,6 +107,16 @@ export function makeStubAstDocumentManager<TAst extends AstNode, TDiagnostic ext
          textDocuments.notifyDidSaveTextDocument({ textDocument: { uri }, text }, clientId);
          return version;
       },
+      delete(): Promise<void> {
+         return notSupported('delete');
+      },
+      // The stub deletes nothing, so no delete is ever under way.
+      isDeleting(): boolean {
+         return false;
+      },
+      attributeDeletion(): string {
+         return UNKNOWN_CLIENT_ID;
+      },
       getAuthor(): string {
          return notSupported('getAuthor');
       },

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

@@ -92,6 +92,8 @@ export interface StubHydraniumTextDocuments extends Pick<
    | 'openedVersion'
    | 'onDidChangeDirty'
    | 'setDiskBaseline'
+   | 'markCreated'
+   | 'isUnsavedCreation'
 > {
    /**
     * Stub-tailored read accessor. Returns just the surface the framework's
@@ -173,6 +175,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 created = new Set<string>();
    const openedVersions = new Map<string, number>();
    const dirty = new Set<string>();
    const dirtyChanged = new Emitter<DocumentDirtyChangedEvent>();
@@ -329,9 +332,22 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
       setDiskBaseline(uri, text) {
          if (docs.has(uri)) {
             baselines.set(uri, text);
+            if (text !== undefined) {
+               created.delete(uri);
+            }
+            refreshDirty(uri);
+         }
+      },
+      markCreated(uri) {
+         if (docs.has(uri)) {
+            baselines.set(uri, undefined);
+            created.add(uri);
             refreshDirty(uri);
          }
       },
+      isUnsavedCreation(uri) {
+         return created.has(uri);
+      },
       openDocuments() {
          // From the registry that also answers `isOpenInClient`, which both
          // seeding channels feed, so the two never disagree about an open.
@@ -355,6 +371,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          docs.set(uri, { uri, version: 1, text, clientId });
          openedVersions.set(uri, 1);
          baselines.set(uri, text);
+         created.delete(uri);
       },
       seedOpenInLanguageClient(uri) {
          sessions.addOpen(key(uri), LANGUAGE_CLIENT_ID);
@@ -368,6 +385,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          const dropped = holder !== undefined && holder.clientId === clientId;
          if (dropped) {
             docs.delete(uri);
+            created.delete(uri);
          }
          const removed = sessions.removeOpen(key(uri), clientId);
          if (clientId === LANGUAGE_CLIENT_ID) {
@@ -393,6 +411,7 @@ export function makeStubHydraniumTextDocuments(): StubHydraniumTextDocuments {
          appliedEdits.length = 0;
          staged.length = 0;
          baselines.clear();
+         created.clear();
          openedVersions.clear();
          dirty.clear();
          saveListeners.length = 0;