@rljson/fs-agent 0.0.19 → 0.0.20

package/dist/fs-agent.js

@@ -441,6 +441,8 @@ class FsScanner {
   _nextBlobCache = /* @__PURE__ */ new Map();
   /** Ensures the persisted cache is read from disk only once. */
   _cacheLoaded = false;
+  /** Entries that vanished mid-scan, counted per {@link scan} for one summary. */
+  _vanishedDuringScan = 0;
   constructor(rootPath, options = {}) {
     this._rootPath = rootPath;
     this._options = {
@@ -485,6 +487,7 @@ class FsScanner {
       this._nextBlobCache = /* @__PURE__ */ new Map();
     }
     const trees = /* @__PURE__ */ new Map();
+    this._vanishedDuringScan = 0;
     let rootTree;
     try {
       rootTree = await this._scanDirectory(this._rootPath, ".", 0, trees);
@@ -500,6 +503,11 @@ class FsScanner {
         "Failed to generate hash for root tree. Tree structure may be invalid."
       );
     }
+    if (this._vanishedDuringScan > 0) {
+      console.warn(
+        `[fs-scanner] ${this._vanishedDuringScan} entr${this._vanishedDuringScan === 1 ? "y" : "ies"} vanished during the scan of ${this._rootPath} — skipped; the next scan picks up the settled state`
+      );
+    }
     trees.set(rootHashStr, rootTree);
     this._tree = {
       rootHash: rootHashStr,
@@ -513,6 +521,7 @@ class FsScanner {
   }
   async _scanDirectory(absolutePath, relativePath, depth, trees) {
     const entries = await readdir(absolutePath, { withFileTypes: true });
+    const childTrees = [];
     const childRefs = [];
     for (const entry of entries) {
       if (this._shouldIgnore(entry.name)) {
@@ -526,78 +535,87 @@ class FsScanner {
       if (this._options.maxDepth !== void 0 && depth >= this._options.maxDepth) {
         continue;
       }
-      const childStats = await stat(childPath);
-      if (entry.isDirectory()) {
-        const childTree = await this._scanDirectory(
-          childPath,
-          childRelPath,
-          depth + 1,
-          trees
-        );
-        hip(childTree);
-        const childHashStr = childTree._hash;
-        trees.set(childHashStr, childTree);
-        childRefs.push(childHashStr);
-      } else if (entry.isFile()) {
-        const mtimeMs = childStats.mtime.getTime();
-        const cached = this._scanCachePath ? this._blobCache.get(childRelPath) : void 0;
-        let blobId;
-        if (cached && cached.mtime === mtimeMs && cached.size === childStats.size) {
-          blobId = cached.blobId;
-        } else {
-          let fileContent;
-          try {
-            fileContent = await readFile(childPath);
-          } catch (error) {
-            throw new Error(
-              `Failed to read file "${childRelPath}": ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-          let blobProps;
-          try {
-            blobProps = await this._bs.setBlob(fileContent);
-          } catch (error) {
-            throw new Error(
-              `Failed to store blob for file "${childRelPath}": ${error instanceof Error ? error.message : String(error)}`
-            );
+      try {
+        const childStats = await stat(childPath);
+        if (entry.isDirectory()) {
+          const childTree = await this._scanDirectory(
+            childPath,
+            childRelPath,
+            depth + 1,
+            trees
+          );
+          childTrees.push(childTree);
+          hip(childTree);
+          const childHashStr = childTree._hash;
+          trees.set(childHashStr, childTree);
+          childRefs.push(childHashStr);
+        } else if (entry.isFile()) {
+          const mtimeMs = childStats.mtime.getTime();
+          const cached = this._scanCachePath ? this._blobCache.get(childRelPath) : void 0;
+          let blobId;
+          if (cached && cached.mtime === mtimeMs && cached.size === childStats.size) {
+            blobId = cached.blobId;
+          } else {
+            let fileContent;
+            try {
+              fileContent = await readFile(childPath);
+            } catch (error) {
+              if (FsScanner._isVanished(error)) throw error;
+              throw new Error(
+                `Failed to read file "${childRelPath}": ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            let blobProps;
+            try {
+              blobProps = await this._bs.setBlob(fileContent);
+            } catch (error) {
+              throw new Error(
+                `Failed to store blob for file "${childRelPath}": ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            if (!blobProps || !blobProps.blobId) {
+              throw new Error(
+                `Blob storage returned invalid blobId for file "${childRelPath}"`
+              );
+            }
+            blobId = blobProps.blobId;
           }
-          if (!blobProps || !blobProps.blobId) {
-            throw new Error(
-              `Blob storage returned invalid blobId for file "${childRelPath}"`
-            );
+          if (this._scanCachePath) {
+            this._nextBlobCache.set(childRelPath, {
+              mtime: mtimeMs,
+              size: childStats.size,
+              blobId
+            });
           }
-          blobId = blobProps.blobId;
-        }
-        if (this._scanCachePath) {
-          this._nextBlobCache.set(childRelPath, {
-            mtime: mtimeMs,
+          const fileMeta = {
+            name: entry.name,
+            type: "file",
+            relativePath: childRelPath,
             size: childStats.size,
+            // mtime is kept for files (restore preserves it, so it round-trips to
+            // the same ref on every client) but NOT for directories (a folder's
+            // mtime is per-machine and does not round-trip). The absolute `path`
+            // is excluded everywhere — it is folder-specific.
+            mtime: mtimeMs,
             blobId
-          });
+            // Link to content in Bs
+          };
+          const fileTree = {
+            id: entry.name,
+            isParent: false,
+            meta: fileMeta,
+            children: null
+          };
+          childTrees.push(fileTree);
+          hip(fileTree);
+          const fileTreeHashStr = fileTree._hash;
+          trees.set(fileTreeHashStr, fileTree);
+          childRefs.push(fileTreeHashStr);
         }
-        const fileMeta = {
-          name: entry.name,
-          type: "file",
-          relativePath: childRelPath,
-          size: childStats.size,
-          // mtime is kept for files (restore preserves it, so it round-trips to
-          // the same ref on every client) but NOT for directories (a folder's
-          // mtime is per-machine and does not round-trip). The absolute `path`
-          // is excluded everywhere — it is folder-specific.
-          mtime: mtimeMs,
-          blobId
-          // Link to content in Bs
-        };
-        const fileTree = {
-          id: entry.name,
-          isParent: false,
-          meta: fileMeta,
-          children: null
-        };
-        hip(fileTree);
-        const fileTreeHashStr = fileTree._hash;
-        trees.set(fileTreeHashStr, fileTree);
-        childRefs.push(fileTreeHashStr);
+      } catch (error) {
+        if (!FsScanner._isVanished(error)) throw error;
+        this._vanishedDuringScan++;
+        continue;
       }
     }
     const dirName = relativePath === "." ? "." : (
@@ -766,6 +784,20 @@ class FsScanner {
   static _errMessage(err) {
     return err instanceof Error ? err.message : String(err);
   }
+  /**
+   * Whether a caught value is a "no longer there" filesystem error.
+   *
+   * A scan walks a directory that is still being written to. `readdir` returns
+   * a name, and by the time the entry is `stat`ed, read, or descended into it
+   * can be gone — a save-and-rename editor, a build tool, a peer applying a
+   * deletion. That is ordinary, not exceptional.
+   * @param err - The caught value.
+   * @returns `true` for ENOENT / ENOTDIR.
+   */
+  static _isVanished(err) {
+    const code = err?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+  }
   /** Whether the host is Windows — gates Windows-specific watcher hardening. */
   static get _isWindows() {
     return process.platform === "win32";

package/dist/fs-scanner.d.ts

@@ -117,6 +117,8 @@ export declare class FsScanner {
     private _nextBlobCache;
     /** Ensures the persisted cache is read from disk only once. */
     private _cacheLoaded;
+    /** Entries that vanished mid-scan, counted per {@link scan} for one summary. */
+    private _vanishedDuringScan;
     constructor(rootPath: string, options?: FsScanOptions);
     get tree(): FsTree | null;
     get rootPath(): string;
@@ -156,6 +158,17 @@ export declare class FsScanner {
      * @returns A message string
      */
     private static _errMessage;
+    /**
+     * Whether a caught value is a "no longer there" filesystem error.
+     *
+     * A scan walks a directory that is still being written to. `readdir` returns
+     * a name, and by the time the entry is `stat`ed, read, or descended into it
+     * can be gone — a save-and-rename editor, a build tool, a peer applying a
+     * deletion. That is ordinary, not exceptional.
+     * @param err - The caught value.
+     * @returns `true` for ENOENT / ENOTDIR.
+     */
+    private static _isVanished;
     /** Whether the host is Windows — gates Windows-specific watcher hardening. */
     private static get _isWindows();
     private _handleFileChange;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/fs-agent",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Rljson fs-agent description",
   "homepage": "https://github.com/rljson/fs-agent",
   "bugs": "https://github.com/rljson/fs-agent/issues",