zen-fs-config 0.5.9 → 0.5.11

package/dist/index.d.mts

@@ -515,8 +515,19 @@ declare class ConfigRepo implements IConfigRepo {
     /**
      * Before sync: for each tombstone, delete the actual file on all replicas.
      * This prevents bi-directional sync from copying the file back.
+     *
+     * Before calling unlink() on each backend, we check exists() first.
+     * This avoids sending wasteful DELETE requests (or GET-then-404) to
+     * remote backends when the file was already removed on a previous cycle.
+     * Local backends (IndexedDB) are cheap to check, so the guard is
+     * effectively free for them.
      */
     private processTombstones;
+    /**
+     * Safe existence check — returns false on any error instead of throwing.
+     * Used by processTombstones to avoid unnecessary unlink() calls.
+     */
+    private safeExists;
     /** Public wrapper for processTombstones — used by createConfigRepo. */
     processTombstonesPublic(): Promise<void>;
     /**
@@ -531,6 +542,11 @@ declare class ConfigRepo implements IConfigRepo {
     private updateTombstoneConfirmations;
     /**
      * GC: remove tombstones where all backends in backends.json have confirmed.
+     *
+     * Tombstones are deleted from ALL backends (local + replicas), not just
+     * the local IndexedDB. If we only deleted locally, the sync engine would
+     * see them as "created on target" and copy them back every cycle — causing
+     * an infinite loop of copy → GC → copy → GC.
      */
     private gcTombstones;
     /**

package/dist/index.d.ts

@@ -515,8 +515,19 @@ declare class ConfigRepo implements IConfigRepo {
     /**
      * Before sync: for each tombstone, delete the actual file on all replicas.
      * This prevents bi-directional sync from copying the file back.
+     *
+     * Before calling unlink() on each backend, we check exists() first.
+     * This avoids sending wasteful DELETE requests (or GET-then-404) to
+     * remote backends when the file was already removed on a previous cycle.
+     * Local backends (IndexedDB) are cheap to check, so the guard is
+     * effectively free for them.
      */
     private processTombstones;
+    /**
+     * Safe existence check — returns false on any error instead of throwing.
+     * Used by processTombstones to avoid unnecessary unlink() calls.
+     */
+    private safeExists;
     /** Public wrapper for processTombstones — used by createConfigRepo. */
     processTombstonesPublic(): Promise<void>;
     /**
@@ -531,6 +542,11 @@ declare class ConfigRepo implements IConfigRepo {
     private updateTombstoneConfirmations;
     /**
      * GC: remove tombstones where all backends in backends.json have confirmed.
+     *
+     * Tombstones are deleted from ALL backends (local + replicas), not just
+     * the local IndexedDB. If we only deleted locally, the sync engine would
+     * see them as "created on target" and copy them back every cycle — causing
+     * an infinite loop of copy → GC → copy → GC.
      */
     private gcTombstones;
     /**

package/dist/index.js

@@ -861,37 +861,77 @@ var ConfigRepo = class {
   /**
    * Before sync: for each tombstone, delete the actual file on all replicas.
    * This prevents bi-directional sync from copying the file back.
+   *
+   * Before calling unlink() on each backend, we check exists() first.
+   * This avoids sending wasteful DELETE requests (or GET-then-404) to
+   * remote backends when the file was already removed on a previous cycle.
+   * Local backends (IndexedDB) are cheap to check, so the guard is
+   * effectively free for them.
    */
   async processTombstones() {
     const tombstones = await this.readTombstones();
     if (tombstones.length === 0) return;
-    console.log(`[ConfigRepo] processTombstones: ${tombstones.length} tombstone(s)`);
+    let processed = 0;
+    let alreadyDeleted = 0;
     for (const tombstone of tombstones) {
       const tVersionPath = versionPathFor(tombstone.path);
-      try {
-        await this.cachedFS.unlink(tombstone.path);
-      } catch {
+      const existedOnPrimary = await this.safeExists(this.cachedFS, tombstone.path);
+      console.log(`[ConfigRepo] tombstone check: ${tombstone.path} on primary \u2192 ${existedOnPrimary ? "EXISTS" : "not found"}`);
+      if (existedOnPrimary) {
+        try {
+          await this.cachedFS.unlink(tombstone.path);
+          processed++;
+        } catch {
+        }
       }
-      if (tVersionPath) {
+      if (tVersionPath && await this.safeExists(this.cachedFS, tVersionPath)) {
         try {
           await this.cachedFS.unlink(tVersionPath);
         } catch {
         }
       }
       for (const [replicaId, replica] of this.replicaBackends) {
-        try {
-          await replica.instance.unlink(tombstone.path);
-        } catch {
+        const existed = await this.safeExists(replica.instance, tombstone.path);
+        console.log(`[ConfigRepo] tombstone check: ${tombstone.path} on ${replicaId} \u2192 ${existed ? "EXISTS" : "not found"}`);
+        if (existed) {
+          try {
+            await replica.instance.unlink(tombstone.path);
+            console.log(`[ConfigRepo] tombstone ${tombstone.path}: deleted on ${replicaId}`);
+            processed++;
+          } catch {
+            alreadyDeleted++;
+          }
+        } else {
+          alreadyDeleted++;
         }
-        if (tVersionPath) {
+        if (tVersionPath && await this.safeExists(replica.instance, tVersionPath)) {
           try {
             await replica.instance.unlink(tVersionPath);
           } catch {
           }
         }
-        console.log(`[ConfigRepo] tombstone ${tombstone.path}: deleted on ${replicaId}`);
       }
     }
+    if (processed > 0 || alreadyDeleted > 0) {
+      console.log(`[ConfigRepo] processTombstones: ${tombstones.length} tombstone(s), ${processed} deleted, ${alreadyDeleted} already gone`);
+    }
+  }
+  /**
+   * Safe existence check — returns false on any error instead of throwing.
+   * Used by processTombstones to avoid unnecessary unlink() calls.
+   */
+  async safeExists(fs, path) {
+    try {
+      if (typeof fs.exists === "function") {
+        const result = await fs.exists(path);
+        return result;
+      }
+      await fs.stat(path);
+      return true;
+    } catch (err) {
+      console.log(`[ConfigRepo] safeExists(${path}): threw ${err?.code ?? err?.status ?? ""} ${err?.message ?? err}`);
+      return false;
+    }
   }
   /** Public wrapper for processTombstones — used by createConfigRepo. */
   async processTombstonesPublic() {
@@ -937,6 +977,11 @@ var ConfigRepo = class {
   }
   /**
    * GC: remove tombstones where all backends in backends.json have confirmed.
+   *
+   * Tombstones are deleted from ALL backends (local + replicas), not just
+   * the local IndexedDB. If we only deleted locally, the sync engine would
+   * see them as "created on target" and copy them back every cycle — causing
+   * an infinite loop of copy → GC → copy → GC.
    */
   async gcTombstones() {
     const tombstones = await this.readTombstones();
@@ -949,9 +994,17 @@ var ConfigRepo = class {
         const tombstonePath = `${DELETIONS_DIR}/${tombstoneFileName(tombstone.path)}`;
         try {
           await this.cachedFS.unlink(tombstonePath);
-          console.log(`[ConfigRepo] gcTombstones: removed ${tombstonePath} (all ${allBackendIds.length} backends confirmed)`);
         } catch {
         }
+        for (const [replicaId, replica] of this.replicaBackends) {
+          if (await this.safeExists(replica.instance, tombstonePath)) {
+            try {
+              await replica.instance.unlink(tombstonePath);
+            } catch {
+            }
+          }
+        }
+        console.log(`[ConfigRepo] gcTombstones: removed ${tombstonePath} (all ${allBackendIds.length} backends confirmed)`);
       }
     }
   }

package/dist/index.mjs

@@ -771,37 +771,77 @@ var ConfigRepo = class {
   /**
    * Before sync: for each tombstone, delete the actual file on all replicas.
    * This prevents bi-directional sync from copying the file back.
+   *
+   * Before calling unlink() on each backend, we check exists() first.
+   * This avoids sending wasteful DELETE requests (or GET-then-404) to
+   * remote backends when the file was already removed on a previous cycle.
+   * Local backends (IndexedDB) are cheap to check, so the guard is
+   * effectively free for them.
    */
   async processTombstones() {
     const tombstones = await this.readTombstones();
     if (tombstones.length === 0) return;
-    console.log(`[ConfigRepo] processTombstones: ${tombstones.length} tombstone(s)`);
+    let processed = 0;
+    let alreadyDeleted = 0;
     for (const tombstone of tombstones) {
       const tVersionPath = versionPathFor(tombstone.path);
-      try {
-        await this.cachedFS.unlink(tombstone.path);
-      } catch {
+      const existedOnPrimary = await this.safeExists(this.cachedFS, tombstone.path);
+      console.log(`[ConfigRepo] tombstone check: ${tombstone.path} on primary \u2192 ${existedOnPrimary ? "EXISTS" : "not found"}`);
+      if (existedOnPrimary) {
+        try {
+          await this.cachedFS.unlink(tombstone.path);
+          processed++;
+        } catch {
+        }
       }
-      if (tVersionPath) {
+      if (tVersionPath && await this.safeExists(this.cachedFS, tVersionPath)) {
         try {
           await this.cachedFS.unlink(tVersionPath);
         } catch {
         }
       }
       for (const [replicaId, replica] of this.replicaBackends) {
-        try {
-          await replica.instance.unlink(tombstone.path);
-        } catch {
+        const existed = await this.safeExists(replica.instance, tombstone.path);
+        console.log(`[ConfigRepo] tombstone check: ${tombstone.path} on ${replicaId} \u2192 ${existed ? "EXISTS" : "not found"}`);
+        if (existed) {
+          try {
+            await replica.instance.unlink(tombstone.path);
+            console.log(`[ConfigRepo] tombstone ${tombstone.path}: deleted on ${replicaId}`);
+            processed++;
+          } catch {
+            alreadyDeleted++;
+          }
+        } else {
+          alreadyDeleted++;
         }
-        if (tVersionPath) {
+        if (tVersionPath && await this.safeExists(replica.instance, tVersionPath)) {
           try {
             await replica.instance.unlink(tVersionPath);
           } catch {
           }
         }
-        console.log(`[ConfigRepo] tombstone ${tombstone.path}: deleted on ${replicaId}`);
       }
     }
+    if (processed > 0 || alreadyDeleted > 0) {
+      console.log(`[ConfigRepo] processTombstones: ${tombstones.length} tombstone(s), ${processed} deleted, ${alreadyDeleted} already gone`);
+    }
+  }
+  /**
+   * Safe existence check — returns false on any error instead of throwing.
+   * Used by processTombstones to avoid unnecessary unlink() calls.
+   */
+  async safeExists(fs, path) {
+    try {
+      if (typeof fs.exists === "function") {
+        const result = await fs.exists(path);
+        return result;
+      }
+      await fs.stat(path);
+      return true;
+    } catch (err) {
+      console.log(`[ConfigRepo] safeExists(${path}): threw ${err?.code ?? err?.status ?? ""} ${err?.message ?? err}`);
+      return false;
+    }
   }
   /** Public wrapper for processTombstones — used by createConfigRepo. */
   async processTombstonesPublic() {
@@ -847,6 +887,11 @@ var ConfigRepo = class {
   }
   /**
    * GC: remove tombstones where all backends in backends.json have confirmed.
+   *
+   * Tombstones are deleted from ALL backends (local + replicas), not just
+   * the local IndexedDB. If we only deleted locally, the sync engine would
+   * see them as "created on target" and copy them back every cycle — causing
+   * an infinite loop of copy → GC → copy → GC.
    */
   async gcTombstones() {
     const tombstones = await this.readTombstones();
@@ -859,9 +904,17 @@ var ConfigRepo = class {
         const tombstonePath = `${DELETIONS_DIR}/${tombstoneFileName(tombstone.path)}`;
         try {
           await this.cachedFS.unlink(tombstonePath);
-          console.log(`[ConfigRepo] gcTombstones: removed ${tombstonePath} (all ${allBackendIds.length} backends confirmed)`);
         } catch {
         }
+        for (const [replicaId, replica] of this.replicaBackends) {
+          if (await this.safeExists(replica.instance, tombstonePath)) {
+            try {
+              await replica.instance.unlink(tombstonePath);
+            } catch {
+            }
+          }
+        }
+        console.log(`[ConfigRepo] gcTombstones: removed ${tombstonePath} (all ${allBackendIds.length} backends confirmed)`);
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-fs-config",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "Distributed config management library built on ZenFS, zen-fs-cache, and zen-fs-sync",
   "main": "dist/index.js",
   "module": "dist/index.mjs",