zen-fs-config 0.5.34 → 0.5.36

package/dist/{cache-wrapper-XQCPZJCD.mjs → cache-wrapper-S5HRLRQX.mjs}

@@ -9,12 +9,23 @@ function wrapWithCache(backend, backendId, options) {
   } else {
     store = new MemoryCacheStore();
   }
+  try {
+    const purge = store.purgeKeepFiles?.();
+    if (purge && typeof purge.catch === "function") {
+      purge.catch(() => {
+      });
+    }
+  } catch {
+  }
   const wrapped = new CachedFileSystem(backend, store, {
     ttlMs: options.ttlMs ?? 0
   });
   if (typeof backend.shouldSync === "function") {
     wrapped.shouldSync = (...args) => backend.shouldSync(...args);
   }
+  if (typeof backend.writeFileWithMtime === "function") {
+    wrapped.writeFileWithMtime = (path, data, mtimeMs) => backend.writeFileWithMtime(path, data, mtimeMs);
+  }
   return wrapped;
 }
 export {

package/dist/index.js

@@ -385,12 +385,23 @@ function wrapWithCache(backend, backendId, options) {
   } else {
     store = new import_zen_fs_cache.MemoryCacheStore();
   }
+  try {
+    const purge = store.purgeKeepFiles?.();
+    if (purge && typeof purge.catch === "function") {
+      purge.catch(() => {
+      });
+    }
+  } catch {
+  }
   const wrapped = new import_zen_fs_cache.CachedFileSystem(backend, store, {
     ttlMs: options.ttlMs ?? 0
   });
   if (typeof backend.shouldSync === "function") {
     wrapped.shouldSync = (...args) => backend.shouldSync(...args);
   }
+  if (typeof backend.writeFileWithMtime === "function") {
+    wrapped.writeFileWithMtime = (path, data, mtimeMs) => backend.writeFileWithMtime(path, data, mtimeMs);
+  }
   return wrapped;
 }
 var import_zen_fs_cache;

package/dist/index.mjs

@@ -1635,7 +1635,7 @@ var ConfigRepo = class {
         const instance = await createBackend(desc);
         let fsInstance = instance;
         if (this.cacheOptions) {
-          const { wrapWithCache } = await import("./cache-wrapper-XQCPZJCD.mjs");
+          const { wrapWithCache } = await import("./cache-wrapper-S5HRLRQX.mjs");
           fsInstance = wrapWithCache(instance, desc.id, this.cacheOptions);
           log2.log(`[ConfigRepo] Replica ${desc.id} wrapped with CachedFileSystem (store=${this.cacheOptions.storeType ?? "IdbCacheStore"})`);
         }

package/dist/zen-fs-config.js

@@ -24886,10 +24886,35 @@ var ZenFSConfig = (() => {
         }
         async exists(path) {
           try {
+            const innerType = this.inner?.constructor?.name ?? typeof this.inner;
+            const hasStat = typeof this.inner?.stat === "function";
+            const hasExists = typeof this.inner?.exists === "function";
+            const backendName = this.inner?.backendName ?? this.inner?.constructor?.name ?? "unknown";
+            console.log(`[CACHE-EXISTS] exists(${path}): inner=${innerType} backend=${backendName} hasStat=${hasStat} hasExists=${hasExists}`);
+            const statKey = `stat:${path}`;
+            const cachedStat = await this.store.get(statKey);
+            if (cachedStat) {
+              const age = Date.now() - cachedStat.cachedAt;
+              console.log(`[CACHE-EXISTS] exists(${path}): cached stat entry found, age=${age}ms, ttlMs=${this.ttlMs}`);
+            } else {
+              console.log(`[CACHE-EXISTS] exists(${path}): no cached stat entry`);
+            }
+            if (hasExists) {
+              console.log(`[CACHE-EXISTS] exists(${path}): \u2192 calling inner.exists() [backend=${backendName}]`);
+              const result = await this.inner.exists(path);
+              console.log(`[CACHE-EXISTS] exists(${path}): \u2190 inner.exists() [backend=${backendName}] \u2192 ${result}`);
+              return result;
+            }
+            console.log(`[CACHE-EXISTS] exists(${path}): no inner.exists(), falling back to inner.stat() [backend=${backendName}]`);
             await this.inner.stat(path);
+            console.log(`[CACHE-EXISTS] exists(${path}): \u2190 inner.stat() [backend=${backendName}] \u2192 OK (exists)`);
             return true;
           } catch (err2) {
-            if (this.isNotFound(err2)) return false;
+            if (this.isNotFound(err2)) {
+              console.log(`[CACHE-EXISTS] exists(${path}): \u2190 inner.stat() \u2192 NotFound`);
+              return false;
+            }
+            console.log(`[CACHE-EXISTS] exists(${path}): \u2190 inner.stat() \u2192 ERROR: ${err2}`);
             throw err2;
           }
         }
@@ -24922,7 +24947,10 @@ var ZenFSConfig = (() => {
           await this.invalidateMeta(path);
         }
         async unlink(path) {
+          const backendName = this.inner?.backendName ?? this.inner?.constructor?.name ?? "unknown";
+          console.log(`[CACHE-UNLINK] unlink(${path}): calling inner.unlink() [backend=${backendName}]`);
           await this.inner.unlink(path);
+          console.log(`[CACHE-UNLINK] unlink(${path}): inner.unlink() OK [backend=${backendName}], invalidating cache`);
           await this.invalidate(path);
         }
         async mkdir(path, options) {
@@ -24981,6 +25009,12 @@ var ZenFSConfig = (() => {
         async clear() {
           this.store.clear();
         }
+        async purgeKeepFiles() {
+          for (const key of Array.from(this.store.keys())) {
+            const base = key === "/" ? "" : key.split("/").pop() ?? "";
+            if (base === ".keep") this.store.delete(key);
+          }
+        }
       };
       IdbCacheStore = class {
         constructor(prefix = "zen-fs-cache:", dbName = "zen-fs-cache", storeName = "cache") {
@@ -25061,6 +25095,28 @@ var ZenFSConfig = (() => {
           } catch {
           }
         }
+        async purgeKeepFiles() {
+          try {
+            const db = await this.open();
+            await new Promise((resolve4, reject) => {
+              const tx = db.transaction(this.storeName, "readwrite");
+              const store = tx.objectStore(this.storeName);
+              const req = store.getAllKeys();
+              req.onsuccess = () => {
+                const keys = req.result ?? [];
+                for (const raw of keys) {
+                  const path = raw.startsWith(this.prefix) ? raw.slice(this.prefix.length) : raw;
+                  const base = path === "/" ? "" : path.split("/").pop() ?? "";
+                  if (base === ".keep") store.delete(raw);
+                }
+              };
+              req.onerror = () => reject(req.error);
+              tx.oncomplete = () => resolve4();
+              tx.onerror = () => reject(tx.error);
+            });
+          } catch {
+          }
+        }
       };
     }
   });
@@ -25079,12 +25135,23 @@ var ZenFSConfig = (() => {
     } else {
       store = new MemoryCacheStore();
     }
+    try {
+      const purge = store.purgeKeepFiles?.();
+      if (purge && typeof purge.catch === "function") {
+        purge.catch(() => {
+        });
+      }
+    } catch {
+    }
     const wrapped = new CachedFileSystem(backend, store, {
       ttlMs: options.ttlMs ?? 0
     });
     if (typeof backend.shouldSync === "function") {
       wrapped.shouldSync = (...args) => backend.shouldSync(...args);
     }
+    if (typeof backend.writeFileWithMtime === "function") {
+      wrapped.writeFileWithMtime = (path, data, mtimeMs) => backend.writeFileWithMtime(path, data, mtimeMs);
+    }
     return wrapped;
   }
   var init_cache_wrapper = __esm({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-fs-config",
-  "version": "0.5.34",
+  "version": "0.5.36",
   "description": "Distributed config management library built on ZenFS, zen-fs-cache, and zen-fs-sync",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -80,7 +80,7 @@
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^1.6.1",
-    "zen-fs-cache": "^1.0.1",
+    "zen-fs-cache": "^1.0.6",
     "zen-fs-sync": "^0.4.9"
   }
 }