zen-fs-config 0.5.8 → 0.5.10

package/dist/cache-wrapper-XQCPZJCD.mjs

@@ -0,0 +1,22 @@
+// src/cache-wrapper.ts
+import { CachedFileSystem, IdbCacheStore, MemoryCacheStore } from "zen-fs-cache";
+function wrapWithCache(backend, backendId, options) {
+  const storeType = options.storeType ?? "IdbCacheStore";
+  const prefix = options.storePrefix ?? `zen-fs-config:${backendId}:`;
+  let store;
+  if (storeType === "IdbCacheStore") {
+    store = new IdbCacheStore(prefix);
+  } else {
+    store = new MemoryCacheStore();
+  }
+  const wrapped = new CachedFileSystem(backend, store, {
+    ttlMs: options.ttlMs ?? 0
+  });
+  if (typeof backend.shouldSync === "function") {
+    wrapped.shouldSync = (...args) => backend.shouldSync(...args);
+  }
+  return wrapped;
+}
+export {
+  wrapWithCache
+};

package/dist/index.d.mts

@@ -89,11 +89,20 @@ interface ConfigSerializer {
 }
 /** Cache configuration. */
 interface CacheOptions {
-    /** Type of cache store. */
+    /**
+     * Type of cache store for replica backends.
+     * Default: `'IdbCacheStore'` — persists across page reloads so cached
+     * content + revision tokens survive. Use `'MemoryCacheStore'` for
+     * session-only caching (lost on reload).
+     */
     storeType?: 'MemoryCacheStore' | 'IdbCacheStore';
-    /** Cache store prefix (for IdbCacheStore). */
+    /** Cache store prefix (for IdbCacheStore). Default: `'zen-fs-config:'`. */
     storePrefix?: string;
-    /** TTL in milliseconds for cache hits without revalidation. Default: 0 (always revalidate). */
+    /**
+     * TTL in milliseconds for cache hits without revalidation.
+     * Default: 0 (always revalidate via `getRevision` — exact, no stale data).
+     * Ignored when the backend implements `getRevision`.
+     */
     ttlMs?: number;
 }
 /** Options for creating a ConfigRepo. */
@@ -119,8 +128,19 @@ interface ConfigRepoOptions {
     idbStoreName?: string;
     /** Node identifier. Auto-detected if not provided (see DESIGN.md §8.2). */
     nodeId?: string;
-    /** Cache configuration. */
-    cache?: CacheOptions;
+    /**
+     * Cache configuration for replica backends.
+     *
+     * - **Default** (omitted): Caching is enabled with `IdbCacheStore`
+     *   (persists across page reloads). Replica backends (Gitee,
+     *   RemoteStorage, etc.) are wrapped with `CachedFileSystem` to avoid
+     *   redundant network reads via `getRevision` revalidation.
+     * - Pass a `CacheOptions` object to customize the store type, prefix,
+     *   or TTL.
+     * - Pass `false` to disable caching entirely (all reads go directly
+     *   to the backend).
+     */
+    cache?: CacheOptions | false;
     /** Custom serializer. */
     serializer?: ConfigSerializer;
     /** Custom conflict handler. Called before auto-resolution. */
@@ -461,10 +481,11 @@ declare class ConfigRepo implements IConfigRepo {
     private disposed;
     private configCache;
     private readonly primaryBackendId;
+    private readonly cacheOptions?;
     private readonly pollIntervalMs?;
     /** Tombstone cache — avoids redundant reads within a single flush() cycle. */
     private tombstoneCache;
-    constructor(appId: string, nodeId: string, primaryBackendId: string, cachedFS: MinimalAsyncFS, serializer: PathAwareSerializer, onConflict?: (conflict: ConflictInfo) => Promise<unknown | null>, pollIntervalMs?: number);
+    constructor(appId: string, nodeId: string, primaryBackendId: string, cachedFS: MinimalAsyncFS, serializer: PathAwareSerializer, onConflict?: (conflict: ConflictInfo) => Promise<unknown | null>, pollIntervalMs?: number, cacheOptions?: CacheOptions);
     /** Full path to this node's directory on the primary backend. */
     get nodePath(): string;
     /** Number of replica backends registered (excludes the local primary). */
@@ -494,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>;
     /**

package/dist/index.d.ts

@@ -89,11 +89,20 @@ interface ConfigSerializer {
 }
 /** Cache configuration. */
 interface CacheOptions {
-    /** Type of cache store. */
+    /**
+     * Type of cache store for replica backends.
+     * Default: `'IdbCacheStore'` — persists across page reloads so cached
+     * content + revision tokens survive. Use `'MemoryCacheStore'` for
+     * session-only caching (lost on reload).
+     */
     storeType?: 'MemoryCacheStore' | 'IdbCacheStore';
-    /** Cache store prefix (for IdbCacheStore). */
+    /** Cache store prefix (for IdbCacheStore). Default: `'zen-fs-config:'`. */
     storePrefix?: string;
-    /** TTL in milliseconds for cache hits without revalidation. Default: 0 (always revalidate). */
+    /**
+     * TTL in milliseconds for cache hits without revalidation.
+     * Default: 0 (always revalidate via `getRevision` — exact, no stale data).
+     * Ignored when the backend implements `getRevision`.
+     */
     ttlMs?: number;
 }
 /** Options for creating a ConfigRepo. */
@@ -119,8 +128,19 @@ interface ConfigRepoOptions {
     idbStoreName?: string;
     /** Node identifier. Auto-detected if not provided (see DESIGN.md §8.2). */
     nodeId?: string;
-    /** Cache configuration. */
-    cache?: CacheOptions;
+    /**
+     * Cache configuration for replica backends.
+     *
+     * - **Default** (omitted): Caching is enabled with `IdbCacheStore`
+     *   (persists across page reloads). Replica backends (Gitee,
+     *   RemoteStorage, etc.) are wrapped with `CachedFileSystem` to avoid
+     *   redundant network reads via `getRevision` revalidation.
+     * - Pass a `CacheOptions` object to customize the store type, prefix,
+     *   or TTL.
+     * - Pass `false` to disable caching entirely (all reads go directly
+     *   to the backend).
+     */
+    cache?: CacheOptions | false;
     /** Custom serializer. */
     serializer?: ConfigSerializer;
     /** Custom conflict handler. Called before auto-resolution. */
@@ -461,10 +481,11 @@ declare class ConfigRepo implements IConfigRepo {
     private disposed;
     private configCache;
     private readonly primaryBackendId;
+    private readonly cacheOptions?;
     private readonly pollIntervalMs?;
     /** Tombstone cache — avoids redundant reads within a single flush() cycle. */
     private tombstoneCache;
-    constructor(appId: string, nodeId: string, primaryBackendId: string, cachedFS: MinimalAsyncFS, serializer: PathAwareSerializer, onConflict?: (conflict: ConflictInfo) => Promise<unknown | null>, pollIntervalMs?: number);
+    constructor(appId: string, nodeId: string, primaryBackendId: string, cachedFS: MinimalAsyncFS, serializer: PathAwareSerializer, onConflict?: (conflict: ConflictInfo) => Promise<unknown | null>, pollIntervalMs?: number, cacheOptions?: CacheOptions);
     /** Full path to this node's directory on the primary backend. */
     get nodePath(): string;
     /** Number of replica backends registered (excludes the local primary). */
@@ -494,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>;
     /**

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/cache-wrapper.ts
+var cache_wrapper_exports = {};
+__export(cache_wrapper_exports, {
+  wrapWithCache: () => wrapWithCache
+});
+function wrapWithCache(backend, backendId, options) {
+  const storeType = options.storeType ?? "IdbCacheStore";
+  const prefix = options.storePrefix ?? `zen-fs-config:${backendId}:`;
+  let store;
+  if (storeType === "IdbCacheStore") {
+    store = new import_zen_fs_cache.IdbCacheStore(prefix);
+  } else {
+    store = new import_zen_fs_cache.MemoryCacheStore();
+  }
+  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);
+  }
+  return wrapped;
+}
+var import_zen_fs_cache;
+var init_cache_wrapper = __esm({
+  "src/cache-wrapper.ts"() {
+    "use strict";
+    import_zen_fs_cache = require("zen-fs-cache");
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -585,10 +618,11 @@ var ConfigRepo = class {
   disposed = false;
   configCache = /* @__PURE__ */ new Map();
   primaryBackendId;
+  cacheOptions;
   pollIntervalMs;
   /** Tombstone cache — avoids redundant reads within a single flush() cycle. */
   tombstoneCache = null;
-  constructor(appId, nodeId, primaryBackendId, cachedFS, serializer, onConflict, pollIntervalMs) {
+  constructor(appId, nodeId, primaryBackendId, cachedFS, serializer, onConflict, pollIntervalMs, cacheOptions) {
     this.appId = appId;
     this.nodeId = nodeId;
     this.primaryBackendId = primaryBackendId;
@@ -598,6 +632,7 @@ var ConfigRepo = class {
     this.replicaBackends = /* @__PURE__ */ new Map();
     this.onConflictCallback = onConflict;
     this.pollIntervalMs = pollIntervalMs;
+    this.cacheOptions = cacheOptions;
     this.fullFS = backendToSyncableFS(cachedFS, primaryBackendId);
     this.fs = createChrootFS(cachedFS, `/${appId}`);
     this.rootFS = createChrootFS(cachedFS, "/");
@@ -826,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() {
@@ -1036,7 +1111,13 @@ var ConfigRepo = class {
       console.log(`[ConfigRepo] Creating replica backend: id=${desc.id}, type=${desc.type}`);
       try {
         const instance = await createBackend(desc);
-        const syncable = backendToSyncableFS(instance, `${desc.type}(${desc.id})`);
+        let fsInstance = instance;
+        if (this.cacheOptions) {
+          const { wrapWithCache: wrapWithCache2 } = await Promise.resolve().then(() => (init_cache_wrapper(), cache_wrapper_exports));
+          fsInstance = wrapWithCache2(instance, desc.id, this.cacheOptions);
+          console.log(`[ConfigRepo] Replica ${desc.id} wrapped with CachedFileSystem (store=${this.cacheOptions.storeType ?? "IdbCacheStore"})`);
+        }
+        const syncable = backendToSyncableFS(fsInstance, `${desc.type}(${desc.id})`);
         const pair = this.syncEngine.addPair(
           this.fullFS,
           syncable,
@@ -1047,7 +1128,7 @@ var ConfigRepo = class {
           },
           "/"
         );
-        this.replicaBackends.set(desc.id, { instance, syncable, pairId: pair.pairId });
+        this.replicaBackends.set(desc.id, { instance: fsInstance, syncable, pairId: pair.pairId });
         const conflictHandler = (event) => {
           this.handleConflict(event);
         };
@@ -1753,6 +1834,7 @@ async function createConfigRepo(appId, options = {}) {
     options: { storeName: idbStoreName }
   });
   const cachedFS = primaryInstance;
+  const cacheOptions = options.cache === false ? void 0 : options.cache ?? {};
   try {
     await primaryInstance.mkdir(META_DIR);
     console.log(`[createConfigRepo] /.meta/ ready`);
@@ -1777,7 +1859,8 @@ async function createConfigRepo(appId, options = {}) {
     cachedFS,
     createSerializerChain(),
     void 0,
-    options.syncPollIntervalMs
+    options.syncPollIntervalMs,
+    cacheOptions
   );
   const oldBackendsMeta = await tempRepo.readMetaFile(BACKENDS_FILE);
   if (oldBackendsMeta && oldBackendsMeta.backends?.length > 0) {
@@ -1843,7 +1926,8 @@ async function createConfigRepo(appId, options = {}) {
     cachedFS,
     serializer,
     options.onConflict,
-    options.syncPollIntervalMs
+    options.syncPollIntervalMs,
+    cacheOptions
   );
   await repo.setupSync(allBackends, LOCAL_IDB_BACKEND_ID, options.syncPollIntervalMs);
   await repo.load();

package/dist/index.mjs

@@ -528,10 +528,11 @@ var ConfigRepo = class {
   disposed = false;
   configCache = /* @__PURE__ */ new Map();
   primaryBackendId;
+  cacheOptions;
   pollIntervalMs;
   /** Tombstone cache — avoids redundant reads within a single flush() cycle. */
   tombstoneCache = null;
-  constructor(appId, nodeId, primaryBackendId, cachedFS, serializer, onConflict, pollIntervalMs) {
+  constructor(appId, nodeId, primaryBackendId, cachedFS, serializer, onConflict, pollIntervalMs, cacheOptions) {
     this.appId = appId;
     this.nodeId = nodeId;
     this.primaryBackendId = primaryBackendId;
@@ -541,6 +542,7 @@ var ConfigRepo = class {
     this.replicaBackends = /* @__PURE__ */ new Map();
     this.onConflictCallback = onConflict;
     this.pollIntervalMs = pollIntervalMs;
+    this.cacheOptions = cacheOptions;
     this.fullFS = backendToSyncableFS(cachedFS, primaryBackendId);
     this.fs = createChrootFS(cachedFS, `/${appId}`);
     this.rootFS = createChrootFS(cachedFS, "/");
@@ -769,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() {
@@ -979,7 +1021,13 @@ var ConfigRepo = class {
       console.log(`[ConfigRepo] Creating replica backend: id=${desc.id}, type=${desc.type}`);
       try {
         const instance = await createBackend(desc);
-        const syncable = backendToSyncableFS(instance, `${desc.type}(${desc.id})`);
+        let fsInstance = instance;
+        if (this.cacheOptions) {
+          const { wrapWithCache } = await import("./cache-wrapper-XQCPZJCD.mjs");
+          fsInstance = wrapWithCache(instance, desc.id, this.cacheOptions);
+          console.log(`[ConfigRepo] Replica ${desc.id} wrapped with CachedFileSystem (store=${this.cacheOptions.storeType ?? "IdbCacheStore"})`);
+        }
+        const syncable = backendToSyncableFS(fsInstance, `${desc.type}(${desc.id})`);
         const pair = this.syncEngine.addPair(
           this.fullFS,
           syncable,
@@ -990,7 +1038,7 @@ var ConfigRepo = class {
           },
           "/"
         );
-        this.replicaBackends.set(desc.id, { instance, syncable, pairId: pair.pairId });
+        this.replicaBackends.set(desc.id, { instance: fsInstance, syncable, pairId: pair.pairId });
         const conflictHandler = (event) => {
           this.handleConflict(event);
         };
@@ -1696,6 +1744,7 @@ async function createConfigRepo(appId, options = {}) {
     options: { storeName: idbStoreName }
   });
   const cachedFS = primaryInstance;
+  const cacheOptions = options.cache === false ? void 0 : options.cache ?? {};
   try {
     await primaryInstance.mkdir(META_DIR);
     console.log(`[createConfigRepo] /.meta/ ready`);
@@ -1720,7 +1769,8 @@ async function createConfigRepo(appId, options = {}) {
     cachedFS,
     createSerializerChain(),
     void 0,
-    options.syncPollIntervalMs
+    options.syncPollIntervalMs,
+    cacheOptions
   );
   const oldBackendsMeta = await tempRepo.readMetaFile(BACKENDS_FILE);
   if (oldBackendsMeta && oldBackendsMeta.backends?.length > 0) {
@@ -1786,7 +1836,8 @@ async function createConfigRepo(appId, options = {}) {
     cachedFS,
     serializer,
     options.onConflict,
-    options.syncPollIntervalMs
+    options.syncPollIntervalMs,
+    cacheOptions
   );
   await repo.setupSync(allBackends, LOCAL_IDB_BACKEND_ID, options.syncPollIntervalMs);
   await repo.load();

package/package.json

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