@rljson/fs-agent 0.0.56 → 0.0.58

package/dist/fs-agent.d.ts

@@ -276,6 +276,14 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /**
+     * Absolute paths of the files this agent has actually TOLD anyone about.
+     *
+     * A prune may only remove a file that peers could know exists. Anything
+     * written since the last announcement is invisible to every sender, so a
+     * tree that lacks it is not deleting it — it simply predates it.
+     */
+    private readonly _announcedFiles;
     /**
      * Files this restore DELETED.
      *
@@ -724,6 +732,14 @@ export declare class FsAgent {
      * @returns `apply`, or the reason it is not news.
      */
     private _inboundRefVerdict;
+    /**
+     * Records the files an announcement carried.
+     *
+     * Called wherever this agent commits to a state as "what peers know" —
+     * its own pushes, and the states it adopts from theirs.
+     * @param tree - The tree that just went out, or was adopted as ours.
+     */
+    private _rememberAnnounced;
     private _adoptAppliedRef;
     /**
      * Derives a deterministic content key from an FsTree.

package/dist/fs-agent.js

@@ -1152,6 +1152,14 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /**
+   * Absolute paths of the files this agent has actually TOLD anyone about.
+   *
+   * A prune may only remove a file that peers could know exists. Anything
+   * written since the last announcement is invisible to every sender, so a
+   * tree that lacks it is not deleting it — it simply predates it.
+   */
+  _announcedFiles = /* @__PURE__ */ new Set();
   /**
    * Files this restore DELETED.
    *
@@ -1939,6 +1947,9 @@ ${err.stack}` : String(err);
           }
         }
       } else if (!expectedFiles.has(fullPath) && preRestore.has(fullPath)) {
+        if (this._announcedFiles.size > 0 && !this._announcedFiles.has(fullPath)) {
+          continue;
+        }
         await rm(fullPath, { force: true });
         this._restorePruned++;
       }
@@ -1988,12 +1999,14 @@ ${err.stack}` : String(err);
       this._currentRef = initialRef;
       this._persistCurrentRef(initialRef);
       this._lastSentContentKey = this._contentKeyFromTree(initialTree);
+      this._rememberAnnounced(initialTree);
     }
     if (initialRef && !isSilentJoiner) {
       this._lastSentRef = initialRef;
       this._currentRef = initialRef;
       this._persistCurrentRef(initialRef);
       this._lastSentContentKey = this._contentKeyFromTree(initialTree);
+      this._rememberAnnounced(initialTree);
       await this._sendRef(
         connector,
         initialRef,
@@ -2030,7 +2043,35 @@ ${err.stack}` : String(err);
             );
             const ref = await FsAgent._withRetry(
               () => FsAgent._withTimeout(
-                dbAdapter.storeFsTree(tree, { ...options, previous }),
+                // skipNotification, because THIS AGENT broadcasts the ref
+                // itself a few lines below, with the ancestry attached.
+                //
+                // Letting the insert notify sends the ref twice, and the
+                // first copy is the wrong one: the connector attaches
+                // whatever predecessors it currently holds, and this push has
+                // not set its own yet — so the ref goes out carrying the
+                // PREVIOUS push's parent. `_sendRef` then sets the right
+                // ancestry and sends again, and every receiver drops that
+                // second copy as already-received.
+                //
+                // Measured on the lab, sender against receivers:
+                //
+                //   sent  6guj63Ox parent yNAJN-wC | seen  parent CtAgdd1w
+                //   sent  UBl35ZQQ parent 6guj63Ox | seen  parent yNAJN-wC
+                //
+                // Every push arriving one parent behind. Harmless while
+                // nothing read the ancestry; now that a receiver prunes only
+                // for a sender that names a state it is in, it means a
+                // correctly-formed deletion is refused by everyone — which is
+                // exactly what the large-folder recipe has been reporting.
+                //
+                // The doubled `[sync:out]` line in every log was this, in
+                // plain sight, for the whole investigation.
+                dbAdapter.storeFsTree(tree, {
+                  ...options,
+                  previous,
+                  skipNotification: true
+                }),
                 this._timeouts.fetchTree,
                 `syncToDb → storeFsTree(${treeKey})`
               ),
@@ -2045,6 +2086,7 @@ ${err.stack}` : String(err);
             }
             this._lastSentRef = ref;
             this._lastSentContentKey = contentKey;
+            this._rememberAnnounced(tree);
             if (parentRef && parentRef !== ref) {
               connector.invalidateReceived(parentRef);
             }
@@ -2311,6 +2353,19 @@ ${err.stack}` : String(err);
     if (!isNewestFromSender) return "stale";
     return "apply";
   }
+  /**
+   * Records the files an announcement carried.
+   *
+   * Called wherever this agent commits to a state as "what peers know" —
+   * its own pushes, and the states it adopts from theirs.
+   * @param tree - The tree that just went out, or was adopted as ours.
+   */
+  _rememberAnnounced(tree) {
+    this._announcedFiles.clear();
+    for (const path of this._getFileContentMap(tree).keys()) {
+      this._announcedFiles.add(join(this._rootPath, path));
+    }
+  }
   _adoptAppliedRef(connector, treeRef) {
     if (this._lastAppliedRef && this._lastAppliedRef !== treeRef) {
       connector.invalidateSent?.(this._lastAppliedRef);
@@ -2380,6 +2435,7 @@ ${err.stack}` : String(err);
         const ref = await dbAdapter.storeFsTree(tree, { previous });
         this._lastSentRef = ref;
         this._lastSentContentKey = this._contentKeyFromTree(tree);
+        this._rememberAnnounced(tree);
         this._currentRef = ref;
         return ref;
       }
@@ -2443,6 +2499,7 @@ ${err.stack}` : String(err);
             this._currentRef = treeRef;
             this._persistCurrentRef(treeRef);
             this._lastSentContentKey = this._contentKeyFromTree(currentTree);
+            this._rememberAnnounced(currentTree);
             return;
           }
           if (this._resolveConflicts && this._currentRef && predecessorRefs && predecessorRefs.length > 0) {
@@ -2517,6 +2574,7 @@ ${err.stack}` : String(err);
           if (!hasNewsOfOurOwn) {
             this._lastSentRef = postRestoreRef;
             this._lastSentContentKey = this._contentKeyFromTree(postRestoreTree);
+            this._rememberAnnounced(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.`

package/package.json

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