@rljson/fs-agent 0.0.26 → 0.0.28

package/dist/fs-agent.d.ts

@@ -274,6 +274,17 @@ export declare class FsAgent {
      * must never be worth failing a sync over.
      * @param ref - The ref the folder is now at.
      */
+    /**
+     * Starts the watcher unless it is already running.
+     *
+     * Both `syncToDb` and `syncFromDb` need a live watcher and either may be
+     * started first. `syncToDb` used to call `watch()` unconditionally, so
+     * starting them in the order `syncFromDb` then `syncToDb` threw "Already
+     * watching" — which quietly forced every caller into push-first, the order
+     * that lets a reconnecting client overwrite the network with a stale tree.
+     * A crash is a poor reason to choose an unsafe order.
+     */
+    private _ensureWatching;
     private _persistCurrentRef;
     /**
      * The ref this folder was last recorded at, from a previous run.

package/dist/fs-agent.js

@@ -458,6 +458,10 @@ class FsScanner {
   get tree() {
     return this._tree;
   }
+  /** Whether a watcher is currently installed. */
+  get isWatching() {
+    return this._watcher !== null;
+  }
   get rootPath() {
     return this._rootPath;
   }
@@ -1161,6 +1165,21 @@ class FsAgent {
    * must never be worth failing a sync over.
    * @param ref - The ref the folder is now at.
    */
+  /**
+   * Starts the watcher unless it is already running.
+   *
+   * Both `syncToDb` and `syncFromDb` need a live watcher and either may be
+   * started first. `syncToDb` used to call `watch()` unconditionally, so
+   * starting them in the order `syncFromDb` then `syncToDb` threw "Already
+   * watching" — which quietly forced every caller into push-first, the order
+   * that lets a reconnecting client overwrite the network with a stale tree.
+   * A crash is a poor reason to choose an unsafe order.
+   */
+  async _ensureWatching() {
+    if (!this._scanner.isWatching) {
+      await this._scanner.watch();
+    }
+  }
   _persistCurrentRef(ref) {
     try {
       writeFileSync(
@@ -1927,7 +1946,7 @@ ${err.stack}` : String(err);
       }, this._timeouts.debounceMs);
     };
     this._scanner.onChange(debouncedSync);
-    await this._scanner.watch();
+    await this._ensureWatching();
     return () => {
       if (debounceTimer) clearTimeout(debounceTimer);
       this._scanner.offChange(debouncedSync);
@@ -2170,14 +2189,13 @@ ${err.stack}` : String(err);
    * @returns Function to stop watching
    */
   async syncFromDb(db, connector, treeKey, restoreOptions) {
-    if (!this._scanner["_watcher"]) {
-      await this._scanner.watch();
-    }
+    await this._ensureWatching();
     let pendingRef = null;
     let fromDbTimer = null;
     let pendingRecoveryAttempt = 0;
     let pendingPredecessorRefs;
-    const processRef = async (treeRef, recoveryAttempt = 0, predecessorRefs) => {
+    let pendingIsNewest = true;
+    const processRef = async (treeRef, recoveryAttempt = 0, predecessorRefs, isNewestFromSender = true) => {
       const maxAttempts = this._timeouts.processRefRetries + 1;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         this._scanner.pauseWatch();
@@ -2230,10 +2248,12 @@ ${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 staleAdvertisement = !isNewestFromSender;
+          const withholdPrune = ancestryExpected && !declaresAncestry || staleAdvertisement;
+          const applyOptions = restoreOptions?.cleanTarget && withholdPrune ? { ...restoreOptions, cleanTarget: false } : restoreOptions;
           if (applyOptions !== restoreOptions) {
             console.warn(
-              `[FsAgent] ref=${treeRef.slice(0, 8)}… declares no ancestry — applying additively, not pruning. A sender that cannot say what it descends from must not delete.`
+              `[FsAgent] ref=${treeRef.slice(0, 8)}… ` + (staleAdvertisement ? "is not the newest its sender has advertised" : "declares no ancestry") + ` — applying additively, not pruning.`
             );
           }
           await FsAgent._withTimeout(
@@ -2305,30 +2325,38 @@ ${err.stack}` : String(err);
         );
       }
     };
-    const scheduleProcess = (ref, delayMs, recoveryAttempt, predecessorRefs) => {
+    const scheduleProcess = (ref, delayMs, recoveryAttempt, predecessorRefs, isNewestFromSender = true) => {
       if (pendingRef && pendingRef !== ref) {
         connector.invalidateReceived(pendingRef);
       }
       pendingRef = ref;
       pendingRecoveryAttempt = recoveryAttempt;
       pendingPredecessorRefs = predecessorRefs;
+      pendingIsNewest = isNewestFromSender;
       if (fromDbTimer) clearTimeout(fromDbTimer);
       fromDbTimer = setTimeout(async () => {
         fromDbTimer = null;
         const r = pendingRef;
         const ra = pendingRecoveryAttempt;
         const pr = pendingPredecessorRefs;
+        const newest = pendingIsNewest;
         pendingRef = null;
         if (r) {
-          await processRef(r, ra, pr);
+          await processRef(r, ra, pr, newest);
         }
       }, delayMs);
     };
-    const syncCallback = (treeRef, predecessorRefs) => {
+    const syncCallback = (treeRef, predecessorRefs, info) => {
       if (!treeRef || typeof treeRef !== "string") {
         return Promise.resolve();
       }
-      scheduleProcess(treeRef, this._timeouts.debounceMs, 0, predecessorRefs);
+      scheduleProcess(
+        treeRef,
+        this._timeouts.debounceMs,
+        0,
+        predecessorRefs,
+        info?.isNewestFromSender ?? true
+      );
       return Promise.resolve();
     };
     connector.listen(syncCallback);

package/dist/fs-scanner.d.ts

@@ -121,6 +121,8 @@ export declare class FsScanner {
     private _vanishedDuringScan;
     constructor(rootPath: string, options?: FsScanOptions);
     get tree(): FsTree | null;
+    /** Whether a watcher is currently installed. */
+    get isWatching(): boolean;
     get rootPath(): string;
     get bs(): Bs;
     scan(): Promise<FsTree>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/fs-agent",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Rljson fs-agent description",
   "homepage": "https://github.com/rljson/fs-agent",
   "bugs": "https://github.com/rljson/fs-agent/issues",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "@rljson/bs": "^0.0.21",
-    "@rljson/db": "^0.0.31",
+    "@rljson/db": "^0.0.32",
     "@rljson/hash": "^0.0.18",
     "@rljson/io": "^0.0.66",
     "@rljson/json": "^0.0.23",