@rljson/fs-agent 0.0.58 → 0.0.60

package/dist/fs-agent.d.ts

@@ -176,6 +176,30 @@ export declare const TREE_FETCH_CONCURRENCY = 64;
  * which is the cheap half of the trade.
  */
 export declare const RESTORED_BLOB_MEMORY_MAX = 50000;
+/**
+ * How many tree children a restore works on at once.
+ *
+ * A restore's cost is dominated by `getBlob`, and a blob this node does not
+ * already hold is a socket round trip. Walking the tree strictly sequentially
+ * makes the whole restore `files × RTT` — invisible on localhost, and about
+ * sixteen files a second on the lab, where a 1 200-file folder then takes
+ * minutes and reads as a stalled node.
+ *
+ * Sixteen rather than sixty-four: blobs carry file CONTENT, so the ceiling is
+ * memory in flight rather than request count, and a folder of large files at
+ * high concurrency is how a client runs out of heap.
+ */
+export declare const RESTORE_FETCH_CONCURRENCY = 16;
+/**
+ * How many of its own past states a node remembers.
+ *
+ * Used to recognise a sender that is BEHIND this node — one that declares a
+ * state this node has held and left. A burst on a large folder produces a few
+ * dozen states, so this is generous; forgetting the oldest costs only the
+ * ability to spot a very stale sender, which the mass-delete guard still
+ * catches.
+ */
+export declare const STATE_HISTORY_MAX = 1000;
 /**
  * What an agent concluded about an inbound ref.
  *
@@ -276,6 +300,15 @@ export declare class FsAgent {
     /** Files written vs left alone by the current {@link restore}. */
     private _restoreWritten;
     private _restoreSkipped;
+    /**
+     * The states this node has held, oldest first.
+     *
+     * A push declaring one of these — but not the current one — comes from a
+     * sender that is behind this node. Applying such a tree is what puts a
+     * deleted file back, so it is ignored outright rather than applied
+     * additively.
+     */
+    private readonly _stateHistory;
     /**
      * Absolute paths of the files this agent has actually TOLD anyone about.
      *
@@ -739,6 +772,17 @@ export declare class FsAgent {
      * its own pushes, and the states it adopts from theirs.
      * @param tree - The tree that just went out, or was adopted as ours.
      */
+    /**
+     * Records a state this node is now in.
+     * @param ref - The content ref of that state.
+     */
+    private _rememberState;
+    /**
+     * Whether a push comes from a sender this node has already moved past.
+     * @param predecessorRefs - What the push declares it descends from.
+     * @returns True when every declared parent is a state this node has left.
+     */
+    private _senderIsBehind;
     private _rememberAnnounced;
     private _adoptAppliedRef;
     /**

package/dist/fs-agent.js

@@ -1079,6 +1079,8 @@ const AGENT_STATE_FILE = ".fsagent-state.json";
 const REFUSAL_ANSWER_COOLDOWN_MS = 5e3;
 const TREE_FETCH_CONCURRENCY = 64;
 const RESTORED_BLOB_MEMORY_MAX = 5e4;
+const RESTORE_FETCH_CONCURRENCY = 16;
+const STATE_HISTORY_MAX = 1e3;
 const VERDICT_REASON = {
   "own-echo": "is this agent's own last advertisement echoed back",
   stale: "is not the newest its sender has advertised"
@@ -1152,6 +1154,15 @@ class FsAgent {
   /** Files written vs left alone by the current {@link restore}. */
   _restoreWritten = 0;
   _restoreSkipped = 0;
+  /**
+   * The states this node has held, oldest first.
+   *
+   * A push declaring one of these — but not the current one — comes from a
+   * sender that is behind this node. Applying such a tree is what puts a
+   * deleted file back, so it is ignored outright rather than applied
+   * additively.
+   */
+  _stateHistory = [];
   /**
    * Absolute paths of the files this agent has actually TOLD anyone about.
    *
@@ -1267,6 +1278,7 @@ class FsAgent {
     }
   }
   _persistCurrentRef(ref) {
+    this._rememberState(ref);
     try {
       writeFileSync(
         join(this._rootPath, AGENT_STATE_FILE),
@@ -1637,9 +1649,26 @@ ${err.stack}` : String(err);
       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, isOwnRoot);
-        }
+        const children = [...treeNode.children];
+        let next = 0;
+        const worker = async () => {
+          for (; ; ) {
+            const index = next++;
+            if (index >= children.length) return;
+            await this._restoreTree(
+              children[index],
+              trees,
+              targetPath,
+              isOwnRoot
+            );
+          }
+        };
+        await Promise.all(
+          Array.from(
+            { length: Math.min(RESTORE_FETCH_CONCURRENCY, children.length) },
+            worker
+          )
+        );
       }
     }
   }
@@ -2360,6 +2389,28 @@ ${err.stack}` : String(err);
    * its own pushes, and the states it adopts from theirs.
    * @param tree - The tree that just went out, or was adopted as ours.
    */
+  /**
+   * Records a state this node is now in.
+   * @param ref - The content ref of that state.
+   */
+  _rememberState(ref) {
+    if (this._stateHistory.includes(ref)) return;
+    this._stateHistory.push(ref);
+    if (this._stateHistory.length > STATE_HISTORY_MAX) {
+      this._stateHistory.shift();
+    }
+  }
+  /**
+   * Whether a push comes from a sender this node has already moved past.
+   * @param predecessorRefs - What the push declares it descends from.
+   * @returns True when every declared parent is a state this node has left.
+   */
+  _senderIsBehind(predecessorRefs) {
+    if (predecessorRefs.length === 0) return false;
+    return predecessorRefs.every(
+      (ref) => ref !== this._currentRef && ref !== this._lastAppliedRef && this._stateHistory.includes(ref)
+    );
+  }
   _rememberAnnounced(tree) {
     this._announcedFiles.clear();
     for (const path of this._getFileContentMap(tree).keys()) {
@@ -2531,6 +2582,12 @@ ${err.stack}` : String(err);
             (r) => r !== void 0
           );
           const senderSawMyState = !ancestryIsCarried || !declaresAncestry || statesIAmIn.some((r) => predecessorRefs.includes(r));
+          if (ancestryIsCarried && declaresAncestry && this._senderIsBehind(predecessorRefs)) {
+            console.warn(
+              `[FsAgent] ref=${treeRef.slice(0, 8)}… descends from a state this node has already left — ignoring, the sender will catch up and re-push.`
+            );
+            return;
+          }
           const withholdPrune = restoreOptions?.cleanTarget && (ancestryExpected && !declaresAncestry || !senderSawMyState);
           const applyOptions = withholdPrune ? { ...restoreOptions, cleanTarget: false } : restoreOptions;
           if (applyOptions !== restoreOptions) {

package/package.json

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