@rljson/fs-agent 0.0.60 → 0.0.62

package/dist/fs-agent.d.ts

@@ -300,6 +300,16 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /**
+     * Absolute paths deleted here since the last announcement.
+     *
+     * The mirror of {@link _announcedFiles}. Between a local unlink and the push
+     * that announces it, this node's advertised state still CONTAINS the file —
+     * so a peer pushing in that window descends from a state the file is in, and
+     * an apply re-creates it. The local scan then sees the file present, and the
+     * deletion is never announced at all: silently undone, everywhere.
+     */
+    private readonly _pendingDeletes;
     /**
      * The states this node has held, oldest first.
      *
@@ -783,6 +793,16 @@ export declare class FsAgent {
      * @returns True when every declared parent is a state this node has left.
      */
     private _senderIsBehind;
+    /**
+     * Marks an incoming tree's files as known to the network.
+     *
+     * A union, not a replacement: {@link _rememberAnnounced} answers "what this
+     * node has told the network", and this answers "what the network has told
+     * this node". Both make a file prunable; neither alone is the whole set, and
+     * treating the first as the whole set is what made deletions vanish.
+     * @param tree - The tree just applied.
+     */
+    private _rememberReceived;
     private _rememberAnnounced;
     private _adoptAppliedRef;
     /**

package/dist/fs-agent.js

@@ -684,6 +684,32 @@ class FsScanner {
     } catch {
     }
   }
+  /**
+   * Whether a watcher event's path should be ignored.
+   *
+   * `fs.watch` in recursive mode reports a path RELATIVE TO THE ROOT
+   * (`sub/dir/.fsagent-tmp-abc`), while the ignore patterns are basenames.
+   * {@link _shouldIgnore} tests `startsWith`, so a nested match never fired:
+   * every atomic write the agent itself makes during a restore came back as a
+   * change event, each event triggered a scan, and the debounce that batches a
+   * push was reset before it could fire.
+   *
+   * Measured on the customer's folder: after a 3 642-file restore the watcher
+   * reported the SAME newly added file nine times and the agent never emitted a
+   * ref for it — `[fs] added: …/probe-….txt` nine times, no `sync:out`. The
+   * file did not fail to arrive; it was never sent.
+   *
+   * Every segment is tested, because the pattern may match a directory as
+   * easily as a file.
+   * @param relativePath - Path as the watcher reports it.
+   * @returns True when any segment matches an ignore pattern.
+   */
+  _shouldIgnorePath(relativePath) {
+    for (const segment of relativePath.split(/[\\/]/)) {
+      if (segment && this._shouldIgnore(segment)) return true;
+    }
+    return false;
+  }
   _shouldIgnore(name) {
     if (!this._options.ignore) {
       return false;
@@ -704,7 +730,7 @@ class FsScanner {
     }
     const onEvent = async (eventType, filename) => {
       if (!filename) return;
-      if (this._shouldIgnore(filename)) {
+      if (this._shouldIgnorePath(filename)) {
         return;
       }
       await this._handleFileChange(eventType, filename);
@@ -1154,6 +1180,16 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /**
+   * Absolute paths deleted here since the last announcement.
+   *
+   * The mirror of {@link _announcedFiles}. Between a local unlink and the push
+   * that announces it, this node's advertised state still CONTAINS the file —
+   * so a peer pushing in that window descends from a state the file is in, and
+   * an apply re-creates it. The local scan then sees the file present, and the
+   * deletion is never announced at all: silently undone, everywhere.
+   */
+  _pendingDeletes = /* @__PURE__ */ new Set();
   /**
    * The states this node has held, oldest first.
    *
@@ -1605,6 +1641,10 @@ ${err.stack}` : String(err);
           this._restoreSkipped++;
           return;
         }
+        if (this._pendingDeletes.has(filePath)) {
+          this._restoreSkipped++;
+          return;
+        }
         let fileBlob;
         try {
           fileBlob = await this._bs.getBlob(meta.blobId);
@@ -2046,9 +2086,12 @@ ${err.stack}` : String(err);
     this._flushDeferredRescan = () => {
       if (!this._rescanDeferred) return;
       this._rescanDeferred = false;
-      debouncedSync({ type: "safety-rescan" });
+      debouncedSync({ type: "safety-rescan", path: "." });
     };
     const debouncedSync = (change) => {
+      if (change?.type === "deleted" && change.path !== ".") {
+        this._pendingDeletes.add(join(this._rootPath, change.path));
+      }
       if (change?.type === "safety-rescan" && this._remoteApplyInFlight) {
         this._rescanDeferred = true;
         return;
@@ -2411,11 +2454,26 @@ ${err.stack}` : String(err);
       (ref) => ref !== this._currentRef && ref !== this._lastAppliedRef && this._stateHistory.includes(ref)
     );
   }
+  /**
+   * Marks an incoming tree's files as known to the network.
+   *
+   * A union, not a replacement: {@link _rememberAnnounced} answers "what this
+   * node has told the network", and this answers "what the network has told
+   * this node". Both make a file prunable; neither alone is the whole set, and
+   * treating the first as the whole set is what made deletions vanish.
+   * @param tree - The tree just applied.
+   */
+  _rememberReceived(tree) {
+    for (const path of this._getFileContentMap(tree).keys()) {
+      this._announcedFiles.add(join(this._rootPath, path));
+    }
+  }
   _rememberAnnounced(tree) {
     this._announcedFiles.clear();
     for (const path of this._getFileContentMap(tree).keys()) {
       this._announcedFiles.add(join(this._rootPath, path));
     }
+    this._pendingDeletes.clear();
   }
   _adoptAppliedRef(connector, treeRef) {
     if (this._lastAppliedRef && this._lastAppliedRef !== treeRef) {
@@ -2619,6 +2677,7 @@ ${err.stack}` : String(err);
           this._adoptAppliedRef(connector, treeRef);
           this._currentRef = postRestoreRef;
           this._persistCurrentRef(postRestoreRef);
+          this._rememberReceived(incomingTree);
           const postRestoreFiles = this._getFileContentMap(postRestoreTree);
           const incomingFiles = this._getFileContentMap(incomingTree);
           let hasNewsOfOurOwn = false;

package/dist/fs-scanner.d.ts

@@ -141,6 +141,27 @@ export declare class FsScanner {
      * (temp + rename). Best-effort: a failed cache write never fails the scan.
      */
     private _persistCache;
+    /**
+     * Whether a watcher event's path should be ignored.
+     *
+     * `fs.watch` in recursive mode reports a path RELATIVE TO THE ROOT
+     * (`sub/dir/.fsagent-tmp-abc`), while the ignore patterns are basenames.
+     * {@link _shouldIgnore} tests `startsWith`, so a nested match never fired:
+     * every atomic write the agent itself makes during a restore came back as a
+     * change event, each event triggered a scan, and the debounce that batches a
+     * push was reset before it could fire.
+     *
+     * Measured on the customer's folder: after a 3 642-file restore the watcher
+     * reported the SAME newly added file nine times and the agent never emitted a
+     * ref for it — `[fs] added: …/probe-….txt` nine times, no `sync:out`. The
+     * file did not fail to arrive; it was never sent.
+     *
+     * Every segment is tested, because the pattern may match a directory as
+     * easily as a file.
+     * @param relativePath - Path as the watcher reports it.
+     * @returns True when any segment matches an ignore pattern.
+     */
+    private _shouldIgnorePath;
     private _shouldIgnore;
     watch(): Promise<void>;
     /**

package/package.json

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