@rljson/fs-agent 0.0.46 → 0.0.48

package/dist/fs-agent.d.ts

@@ -276,6 +276,16 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /**
+     * Files this restore DELETED.
+     *
+     * Counted and reported because a prune is the only half of a restore that
+     * can destroy anything, and until now it was the only half that happened
+     * silently: `restore: wrote 0, left 901 already-correct` is what a node
+     * printed while removing 77 files. The number that mattered was the one not
+     * on the line.
+     */
+    private _restorePruned;
     /** Paths the current {@link restore} could not write because they were held open. */
     private _restoreLocked;
     /**

package/dist/fs-agent.js

@@ -1152,6 +1152,16 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /**
+   * Files this restore DELETED.
+   *
+   * Counted and reported because a prune is the only half of a restore that
+   * can destroy anything, and until now it was the only half that happened
+   * silently: `restore: wrote 0, left 901 already-correct` is what a node
+   * printed while removing 77 files. The number that mattered was the one not
+   * on the line.
+   */
+  _restorePruned = 0;
   /** Paths the current {@link restore} could not write because they were held open. */
   _restoreLocked = [];
   /**
@@ -1481,6 +1491,7 @@ ${err.stack}` : String(err);
     const preRestore = options?.cleanTarget ? await this._collectAllFiles(target) : /* @__PURE__ */ new Set();
     this._restoreWritten = 0;
     this._restoreSkipped = 0;
+    this._restorePruned = 0;
     this._restoreLocked = [];
     await this._restoreTree(
       tree.rootHash,
@@ -1488,9 +1499,9 @@ ${err.stack}` : String(err);
       target,
       target === this._rootPath
     );
-    if (this._restoreSkipped > 0) {
+    if (this._restoreSkipped > 0 || this._restorePruned > 0) {
       console.log(
-        `[FsAgent] restore: wrote ${this._restoreWritten}, left ${this._restoreSkipped} already-correct file${this._restoreSkipped === 1 ? "" : "s"} untouched`
+        `[FsAgent] restore: wrote ${this._restoreWritten}, left ${this._restoreSkipped} already-correct file${this._restoreSkipped === 1 ? "" : "s"} untouched` + (this._restorePruned > 0 ? `, DELETED ${this._restorePruned}` : "")
       );
     }
     if (options?.cleanTarget) {
@@ -1929,6 +1940,7 @@ ${err.stack}` : String(err);
         }
       } else if (!expectedFiles.has(fullPath) && preRestore.has(fullPath)) {
         await rm(fullPath, { force: true });
+        this._restorePruned++;
       }
     }
   }
@@ -2419,10 +2431,10 @@ ${err.stack}` : String(err);
             `syncFromDb → extract(${this._rootPath})`
           );
           if (this._treesHaveEquivalentContent(currentTree, incomingTree)) {
-            const incomingFiles = this._getFileContentMap(incomingTree);
+            const incomingFiles2 = this._getFileContentMap(incomingTree);
             const currentFiles = this._getFileContentMap(currentTree);
             console.log(
-              `[FsAgent] syncFromDb: equivalent content, skipping restore (incoming=${incomingFiles.size} entries, current=${currentFiles.size} entries, ref=${treeRef.slice(0, 8)}…)`
+              `[FsAgent] syncFromDb: equivalent content, skipping restore (incoming=${incomingFiles2.size} entries, current=${currentFiles.size} entries, ref=${treeRef.slice(0, 8)}…)`
             );
             this._adoptAppliedRef(connector, treeRef);
             this._currentRef = treeRef;
@@ -2460,6 +2472,11 @@ ${err.stack}` : String(err);
               `[FsAgent] ref=${treeRef.slice(0, 8)}… declares no ancestry — applying additively, not pruning.`
             );
           }
+          if (restoreOptions?.cleanTarget) {
+            console.log(
+              `[FsAgent] applying ref=${treeRef.slice(0, 8)}… newestFromSender=${isNewestFromSender} declaresAncestry=${declaresAncestry} mayPrune=${applyOptions === restoreOptions} incomingFiles=${this._getFileContentMap(incomingTree).size} currentFiles=${this._getFileContentMap(currentTree).size}`
+            );
+          }
           await FsAgent._withTimeout(
             this.restore(incomingTree, void 0, applyOptions),
             this._timeouts.restore,
@@ -2479,10 +2496,23 @@ ${err.stack}` : String(err);
           this._adoptAppliedRef(connector, treeRef);
           this._currentRef = postRestoreRef;
           this._persistCurrentRef(postRestoreRef);
-          const postRestoreKey = this._contentKeyFromTree(postRestoreTree);
-          if (postRestoreKey === this._contentKeyFromTree(incomingTree)) {
+          const postRestoreFiles = this._getFileContentMap(postRestoreTree);
+          const incomingFiles = this._getFileContentMap(incomingTree);
+          let hasNewsOfOurOwn = false;
+          for (const path of postRestoreFiles.keys()) {
+            if (!incomingFiles.has(path)) {
+              hasNewsOfOurOwn = true;
+              break;
+            }
+          }
+          if (!hasNewsOfOurOwn) {
             this._lastSentRef = postRestoreRef;
-            this._lastSentContentKey = postRestoreKey;
+            this._lastSentContentKey = this._contentKeyFromTree(postRestoreTree);
+            if (postRestoreFiles.size < incomingFiles.size) {
+              console.log(
+                `[FsAgent] ref=${treeRef.slice(0, 8)}… left this node behind (${postRestoreFiles.size} of ${incomingFiles.size} files) — not announcing a state that is catching up.`
+              );
+            }
           }
           return;
         } catch (err) {

package/package.json

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