@rljson/fs-agent 0.0.31 → 0.0.33

package/dist/fs-agent.d.ts

@@ -148,6 +148,15 @@ export declare const AGENT_STATE_FILE = ".fsagent-state.json";
  * three-file folder is an ordinary edit, and a guard that blocked it would
  * fire constantly on small trees and be turned off.
  */
+/**
+ * How long an agent waits before answering another refusal.
+ *
+ * Two nodes can refuse each other — each holding files the other lacks — and an
+ * unthrottled answer to every refusal is a loop. Long enough that a genuine
+ * catch-up (a restore of the answered ref) completes inside it, short enough
+ * that a node joining an idle network is not left waiting.
+ */
+export declare const REFUSAL_ANSWER_COOLDOWN_MS = 5000;
 export declare const MASS_DELETE_MIN_FILES = 100;
 /**
  * Above this share of the folder, a prune is treated as suspicious rather than
@@ -212,6 +221,8 @@ export declare class FsAgent {
      * state can still reach this agent.
      */
     private _lastAppliedRef?;
+    /** When this agent last answered a refusal, for the cooldown. */
+    private _lastRefusalAnswerMs;
     /** Content fingerprint of the last tree we broadcasted (paths+blobIds) */
     private _lastSentContentKey?;
     /**
@@ -598,6 +609,19 @@ export declare class FsAgent {
      * @param connector - Connector whose dedup sets to retire from.
      * @param treeRef - The ref that now describes this folder.
      */
+    /**
+     * Re-announce this folder's current state after refusing an incoming tree.
+     *
+     * A refusal means the sender holds less than this node does, so it is the one
+     * that needs telling. Without this the network settles into a state that is
+     * stable and wrong: the sparse node cannot push, the full node has nothing
+     * new to push, and nothing moves until an unrelated edit happens somewhere.
+     *
+     * Rate-limited because two nodes can refuse each other — each holding files
+     * the other lacks — and an unthrottled answer to every refusal is a loop.
+     * @param connector - Connector to broadcast on.
+     */
+    private _readvertiseAfterRefusal;
     private _adoptAppliedRef;
     /**
      * Derives a deterministic content key from an FsTree.

package/dist/fs-agent.js

@@ -1027,6 +1027,7 @@ const DISCONNECT_PAUSE_MAX_MS = 3e4;
 const SYNC_ERROR_FILE = ".sync-errors.log";
 const ATOMIC_TMP_PREFIX = ".fsagent-tmp-";
 const AGENT_STATE_FILE = ".fsagent-state.json";
+const REFUSAL_ANSWER_COOLDOWN_MS = 5e3;
 const MASS_DELETE_MIN_FILES = 100;
 const MASS_DELETE_MAX_RATIO = 0.3;
 class RestoreIncompleteError extends Error {
@@ -1069,6 +1070,8 @@ class FsAgent {
    * state can still reach this agent.
    */
   _lastAppliedRef;
+  /** When this agent last answered a refusal, for the cooldown. */
+  _lastRefusalAnswerMs = 0;
   /** Content fingerprint of the last tree we broadcasted (paths+blobIds) */
   _lastSentContentKey;
   /**
@@ -2106,6 +2109,33 @@ ${err.stack}` : String(err);
    * @param connector - Connector whose dedup sets to retire from.
    * @param treeRef - The ref that now describes this folder.
    */
+  /**
+   * Re-announce this folder's current state after refusing an incoming tree.
+   *
+   * A refusal means the sender holds less than this node does, so it is the one
+   * that needs telling. Without this the network settles into a state that is
+   * stable and wrong: the sparse node cannot push, the full node has nothing
+   * new to push, and nothing moves until an unrelated edit happens somewhere.
+   *
+   * Rate-limited because two nodes can refuse each other — each holding files
+   * the other lacks — and an unthrottled answer to every refusal is a loop.
+   * @param connector - Connector to broadcast on.
+   */
+  async _readvertiseAfterRefusal(connector) {
+    const ref = this._currentRef;
+    if (!ref) return;
+    const now = Date.now();
+    if (now - this._lastRefusalAnswerMs < REFUSAL_ANSWER_COOLDOWN_MS) return;
+    this._lastRefusalAnswerMs = now;
+    console.warn(
+      `[FsAgent] refused an incoming tree — re-announcing ${ref.slice(0, 8)}… so the sender can catch up.`
+    );
+    try {
+      await this._sendRef(connector, ref);
+    } catch (err) {
+      console.warn(`[FsAgent] re-announcement failed: ${String(err)}`);
+    }
+  }
   _adoptAppliedRef(connector, treeRef) {
     if (this._lastAppliedRef && this._lastAppliedRef !== treeRef) {
       connector.invalidateSent?.(this._lastAppliedRef);
@@ -2293,6 +2323,8 @@ ${err.stack}` : String(err);
           return;
         } catch (err) {
           if (err instanceof MassDeleteRefusedError) {
+            connector.invalidateReceived(treeRef);
+            await this._readvertiseAfterRefusal(connector);
             return;
           }
           if (err instanceof PartialRestoreError) {

package/package.json

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