@rljson/fs-agent 0.0.50 → 0.0.52

package/dist/fs-agent.d.ts

@@ -276,6 +276,24 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /**
+     * The file set of the newest tree any peer has told this node about.
+     *
+     * Kept so the send path can answer the one question a receiver never can:
+     * am I about to announce my progress through someone else's state?
+     */
+    private _lastKnownRemoteFiles?;
+    /**
+     * Whether a LOCAL deletion has been seen since the last apply.
+     *
+     * The discriminator 0.0.49 lacked. A folder smaller than the newest tree
+     * this node knows about is either a node still catching up or a node someone
+     * deleted files from, and those need opposite treatment — the first must stay
+     * quiet, the second must be heard. The shapes are identical; the CAUSE is
+     * not, and only this node can see it: a deletion arrives as a watcher event,
+     * catching up does not.
+     */
+    private _localDeleteSinceApply;
     /**
      * Files this restore DELETED.
      *

package/dist/fs-agent.js

@@ -1152,6 +1152,24 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /**
+   * The file set of the newest tree any peer has told this node about.
+   *
+   * Kept so the send path can answer the one question a receiver never can:
+   * am I about to announce my progress through someone else's state?
+   */
+  _lastKnownRemoteFiles;
+  /**
+   * Whether a LOCAL deletion has been seen since the last apply.
+   *
+   * The discriminator 0.0.49 lacked. A folder smaller than the newest tree
+   * this node knows about is either a node still catching up or a node someone
+   * deleted files from, and those need opposite treatment — the first must stay
+   * quiet, the second must be heard. The shapes are identical; the CAUSE is
+   * not, and only this node can see it: a deletion arrives as a watcher event,
+   * catching up does not.
+   */
+  _localDeleteSinceApply = false;
   /**
    * Files this restore DELETED.
    *
@@ -2007,6 +2025,7 @@ ${err.stack}` : String(err);
       debouncedSync({ type: "safety-rescan" });
     };
     const debouncedSync = (change) => {
+      if (change?.type === "deleted") this._localDeleteSinceApply = true;
       if (change?.type === "safety-rescan" && this._remoteApplyInFlight) {
         this._rescanDeferred = true;
         return;
@@ -2021,6 +2040,25 @@ ${err.stack}` : String(err);
             if (contentKey === this._lastSentContentKey) {
               return;
             }
+            const known = this._lastKnownRemoteFiles;
+            if (known && !this._localDeleteSinceApply && tree.trees.size > 0) {
+              const mine = this._getFileContentMap(tree);
+              if (mine.size < known.size) {
+                let hasOwn = false;
+                for (const path of mine.keys()) {
+                  if (!known.has(path)) {
+                    hasOwn = true;
+                    break;
+                  }
+                }
+                if (!hasOwn) {
+                  console.log(
+                    `[FsAgent] not announcing ${mine.size} of ${known.size} files — nothing here was deleted locally, so this is a gap rather than news.`
+                  );
+                  return;
+                }
+              }
+            }
             const dbAdapter = new FsDbAdapter(db, treeKey);
             const parentRef = this._currentRef;
             const previous = await this._ancestryPrevious(
@@ -2466,10 +2504,13 @@ ${err.stack}` : String(err);
           }
           const ancestryExpected = this._resolveConflicts;
           const declaresAncestry = (predecessorRefs?.length ?? 0) > 0;
-          const applyOptions = restoreOptions?.cleanTarget && ancestryExpected && !declaresAncestry ? { ...restoreOptions, cleanTarget: false } : restoreOptions;
+          const ancestryIsCarried = connector.syncConfig?.causalOrdering === true;
+          const senderSawMyState = !ancestryIsCarried || this._currentRef !== void 0 && (predecessorRefs?.includes(this._currentRef) ?? false);
+          const withholdPrune = restoreOptions?.cleanTarget && (ancestryExpected && !declaresAncestry || !senderSawMyState);
+          const applyOptions = withholdPrune ? { ...restoreOptions, cleanTarget: false } : restoreOptions;
           if (applyOptions !== restoreOptions) {
             console.warn(
-              `[FsAgent] ref=${treeRef.slice(0, 8)}… declares no ancestry — applying additively, not pruning.`
+              `[FsAgent] ref=${treeRef.slice(0, 8)}… ` + (declaresAncestry ? `descends from ${predecessorRefs?.map((r) => r.slice(0, 8)).join(", ")}, not from the state this node is in (${this._currentRef?.slice(0, 8) ?? "none"})` : "declares no ancestry") + ` — applying additively, not pruning.`
             );
           }
           if (restoreOptions?.cleanTarget) {
@@ -2498,6 +2539,8 @@ ${err.stack}` : String(err);
           this._persistCurrentRef(postRestoreRef);
           const postRestoreFiles = this._getFileContentMap(postRestoreTree);
           const incomingFiles = this._getFileContentMap(incomingTree);
+          this._lastKnownRemoteFiles = incomingFiles;
+          this._localDeleteSinceApply = false;
           let hasNewsOfOurOwn = false;
           for (const path of postRestoreFiles.keys()) {
             if (!incomingFiles.has(path)) {

package/package.json

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