@rljson/fs-agent 0.0.21 → 0.0.22

package/dist/fs-agent.d.ts

@@ -159,6 +159,14 @@ export declare class FsAgent {
      * view — and undo a deletion the peer just made.
      */
     private _remoteApplyInFlight;
+    /** Files written vs left alone by the current {@link restore}. */
+    private _restoreWritten;
+    private _restoreSkipped;
+    /**
+     * What this agent last wrote to each absolute path, so a repeat restore can
+     * recognise its own work without re-reading the file.
+     */
+    private _restoredBlobs;
     private _timeouts;
     /** Client-only: resolve DAG-branch conflicts into merge revisions. */
     private _resolveConflicts;
@@ -292,8 +300,48 @@ export declare class FsAgent {
      * @param treeHash - Hash of the tree node to restore
      * @param trees - Map of all tree nodes
      * @param targetPath - Target directory path
+     * @param isOwnRoot - Whether `targetPath` is this agent's own folder, which
+     *   is the only case where the scanner's view describes these files
      */
     private _restoreTree;
+    /**
+     * The content identity this agent believes is on disk at `filePath`, or
+     * `undefined` when it has no basis for an opinion.
+     *
+     * Two sources, both anchored on a real blobId rather than a guess:
+     * what this agent last wrote there, and what the scanner hashed at its last
+     * scan of the folder (which survives a restart, so a fresh process still
+     * skips an unchanged 80 GB catalogue).
+     * @param filePath - Absolute path of the file.
+     * @param relativePath - Its path within the tree.
+     * @param isOwnRoot - Whether the restore target is this agent's own folder,
+     *   which is the only case where the scanner's view describes this file.
+     * @returns The believed content identity, or `undefined`.
+     */
+    private _knownOnDisk;
+    /**
+     * Whether the file at `filePath` is already the content `meta` describes.
+     *
+     * The decision is anchored on the blobId: a different blobId is always
+     * rewritten, whatever the timestamps say. Hashing the file instead would
+     * mean reading 80 GB to avoid writing 80 GB, which saves nothing — so the
+     * known blobId is verified against a `stat`, which catches a file edited
+     * since this agent last had an opinion about it.
+     *
+     * Deliberately one-directional in its uncertainty: every unclear case
+     * answers `false` and the file is rewritten. A needless write costs time; a
+     * wrongly skipped write leaves the wrong bytes on disk indefinitely.
+     *
+     * Anchoring on the blobId is not belt-and-braces. Size and mtime alone
+     * cannot see a same-size edit made inside the same millisecond — the scan
+     * cache tolerates that, but a restore must not: there the cost is not a
+     * stale cache entry, it is the wrong file contents left in place.
+     * @param filePath - Absolute path of the file to check.
+     * @param meta - The metadata describing the content that should be there.
+     * @param isOwnRoot - Whether the target is this agent's own folder.
+     * @returns `true` only when the file is certainly already correct.
+     */
+    private _alreadyOnDisk;
     /**
      * Gets the current tree structure
      */

package/dist/fs-agent.js

@@ -1050,6 +1050,14 @@ class FsAgent {
    * view — and undo a deletion the peer just made.
    */
   _remoteApplyInFlight = false;
+  /** Files written vs left alone by the current {@link restore}. */
+  _restoreWritten = 0;
+  _restoreSkipped = 0;
+  /**
+   * What this agent last wrote to each absolute path, so a repeat restore can
+   * recognise its own work without re-reading the file.
+   */
+  _restoredBlobs = /* @__PURE__ */ new Map();
   _timeouts;
   /** Client-only: resolve DAG-branch conflicts into merge revisions. */
   _resolveConflicts;
@@ -1313,7 +1321,19 @@ ${err.stack}` : String(err);
       target
     );
     const preRestore = options?.cleanTarget ? await this._collectAllFiles(target) : /* @__PURE__ */ new Set();
-    await this._restoreTree(tree.rootHash, tree.trees, target);
+    this._restoreWritten = 0;
+    this._restoreSkipped = 0;
+    await this._restoreTree(
+      tree.rootHash,
+      tree.trees,
+      target,
+      target === this._rootPath
+    );
+    if (this._restoreSkipped > 0) {
+      console.log(
+        `[FsAgent] restore: wrote ${this._restoreWritten}, left ${this._restoreSkipped} already-correct file${this._restoreSkipped === 1 ? "" : "s"} untouched`
+      );
+    }
     if (options?.cleanTarget) {
       await this._pruneExtraneous(
         target,
@@ -1353,8 +1373,10 @@ ${err.stack}` : String(err);
    * @param treeHash - Hash of the tree node to restore
    * @param trees - Map of all tree nodes
    * @param targetPath - Target directory path
+   * @param isOwnRoot - Whether `targetPath` is this agent's own folder, which
+   *   is the only case where the scanner's view describes these files
    */
-  async _restoreTree(treeHash, trees, targetPath) {
+  async _restoreTree(treeHash, trees, targetPath, isOwnRoot) {
     const treeNode = trees.get(treeHash);
     if (!treeNode) {
       throw new Error(`Tree node not found: ${treeHash}`);
@@ -1366,6 +1388,10 @@ ${err.stack}` : String(err);
     if (meta.type === "file") {
       const filePath = join(targetPath, meta.relativePath);
       if (meta.blobId) {
+        if (await this._alreadyOnDisk(filePath, meta, isOwnRoot)) {
+          this._restoreSkipped++;
+          return;
+        }
         let fileBlob;
         try {
           fileBlob = await this._bs.getBlob(meta.blobId);
@@ -1381,21 +1407,93 @@ ${err.stack}` : String(err);
         }
         await mkdir(dirname(filePath), { recursive: true });
         await FsAgent._atomicWriteFile(filePath, fileBlob.content);
+        this._restoreWritten++;
         if (meta.mtime) {
           const mtime = new Date(meta.mtime);
           await utimes(filePath, mtime, mtime);
         }
+        if (meta.size !== void 0 && meta.mtime !== void 0) {
+          this._restoredBlobs.set(filePath, {
+            blobId: meta.blobId,
+            size: meta.size,
+            mtime: meta.mtime
+          });
+        }
       }
     } else if (meta.type === "directory") {
       const dirPath = meta.relativePath === "." ? targetPath : join(targetPath, meta.relativePath);
       await mkdir(dirPath, { recursive: true });
       if (treeNode.children && Array.isArray(treeNode.children)) {
         for (const childHash of treeNode.children) {
-          await this._restoreTree(childHash, trees, targetPath);
+          await this._restoreTree(childHash, trees, targetPath, isOwnRoot);
         }
       }
     }
   }
+  /**
+   * The content identity this agent believes is on disk at `filePath`, or
+   * `undefined` when it has no basis for an opinion.
+   *
+   * Two sources, both anchored on a real blobId rather than a guess:
+   * what this agent last wrote there, and what the scanner hashed at its last
+   * scan of the folder (which survives a restart, so a fresh process still
+   * skips an unchanged 80 GB catalogue).
+   * @param filePath - Absolute path of the file.
+   * @param relativePath - Its path within the tree.
+   * @param isOwnRoot - Whether the restore target is this agent's own folder,
+   *   which is the only case where the scanner's view describes this file.
+   * @returns The believed content identity, or `undefined`.
+   */
+  _knownOnDisk(filePath, relativePath, isOwnRoot) {
+    const written = this._restoredBlobs.get(filePath);
+    if (written) return written;
+    if (!isOwnRoot) return void 0;
+    const scanned = this._scanner.getTreeByPath(relativePath)?.meta;
+    if (scanned?.blobId === void 0 || scanned.size === void 0 || scanned.mtime === void 0) {
+      return void 0;
+    }
+    return {
+      blobId: scanned.blobId,
+      size: scanned.size,
+      mtime: scanned.mtime
+    };
+  }
+  /**
+   * Whether the file at `filePath` is already the content `meta` describes.
+   *
+   * The decision is anchored on the blobId: a different blobId is always
+   * rewritten, whatever the timestamps say. Hashing the file instead would
+   * mean reading 80 GB to avoid writing 80 GB, which saves nothing — so the
+   * known blobId is verified against a `stat`, which catches a file edited
+   * since this agent last had an opinion about it.
+   *
+   * Deliberately one-directional in its uncertainty: every unclear case
+   * answers `false` and the file is rewritten. A needless write costs time; a
+   * wrongly skipped write leaves the wrong bytes on disk indefinitely.
+   *
+   * Anchoring on the blobId is not belt-and-braces. Size and mtime alone
+   * cannot see a same-size edit made inside the same millisecond — the scan
+   * cache tolerates that, but a restore must not: there the cost is not a
+   * stale cache entry, it is the wrong file contents left in place.
+   * @param filePath - Absolute path of the file to check.
+   * @param meta - The metadata describing the content that should be there.
+   * @param isOwnRoot - Whether the target is this agent's own folder.
+   * @returns `true` only when the file is certainly already correct.
+   */
+  async _alreadyOnDisk(filePath, meta, isOwnRoot) {
+    const known = this._knownOnDisk(
+      filePath,
+      meta.relativePath,
+      isOwnRoot
+    );
+    if (!known || known.blobId !== meta.blobId) return false;
+    try {
+      const st = await stat(filePath);
+      return st.size === known.size && Math.abs(st.mtimeMs - known.mtime) < 1;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Gets the current tree structure
    */

package/package.json

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