zen-fs-config 0.5.42 → 0.5.44

package/dist/index.js

@@ -2901,7 +2901,11 @@ var AppDataGroupImpl = class {
   _pollIntervalMs;
   async init() {
     try {
-      const localPrimary = await resolveLocalPrimary(this.appId, "data");
+      const localPrimary = await resolveLocalPrimary(
+        this.appId,
+        "data",
+        this.groupId === "default" ? {} : { idbStoreName: `zen-fs-config-data-${this.appId}-${this.groupId}` }
+      );
       this.localFS = await createBackend(localPrimary);
     } catch {
       throw new Error(`Failed to create local primary for data group "${this.groupId}"`);

package/dist/index.mjs

@@ -2361,7 +2361,11 @@ var AppDataGroupImpl = class {
   _pollIntervalMs;
   async init() {
     try {
-      const localPrimary = await resolveLocalPrimary(this.appId, "data");
+      const localPrimary = await resolveLocalPrimary(
+        this.appId,
+        "data",
+        this.groupId === "default" ? {} : { idbStoreName: `zen-fs-config-data-${this.appId}-${this.groupId}` }
+      );
       this.localFS = await createBackend(localPrimary);
     } catch {
       throw new Error(`Failed to create local primary for data group "${this.groupId}"`);

package/dist/zen-fs-config.js

@@ -1163,7 +1163,7 @@ var ZenFSConfig = (() => {
     fancy: () => fancy,
     format: () => format,
     info: () => info,
-    isEnabled: () => isEnabled,
+    isEnabled: () => isEnabled2,
     levelOf: () => levelOf,
     levels: () => levels,
     log: () => log4,
@@ -1174,7 +1174,7 @@ var ZenFSConfig = (() => {
     return levels.indexOf(value);
   }
   function log4(level, message) {
-    if (!isEnabled)
+    if (!isEnabled2)
       return;
     const entry = {
       level,
@@ -1232,7 +1232,7 @@ var ZenFSConfig = (() => {
     _format = options.format ?? _format;
     _output = options.output ?? _output;
     minLevel = typeof options.level == "string" ? levelOf(options.level) : options.level ?? minLevel;
-    isEnabled = options.enabled ?? isEnabled;
+    isEnabled2 = options.enabled ?? isEnabled2;
     includeStack = options.stack ?? includeStack;
     if (!options.dumpBacklog)
       return;
@@ -1240,7 +1240,7 @@ var ZenFSConfig = (() => {
       output(entry);
     }
   }
-  var Level, levels, entries, emerg, alert, crit, err, warn, notice, info, debug, levelColor, messageColor, _format, _output, minLevel, includeStack, isEnabled;
+  var Level, levels, entries, emerg, alert, crit, err, warn, notice, info, debug, levelColor, messageColor, _format, _output, minLevel, includeStack, isEnabled2;
   var init_log = __esm({
     "node_modules/kerium/dist/log.js"() {
       "use strict";
@@ -1322,7 +1322,7 @@ var ZenFSConfig = (() => {
       _output = console.error;
       minLevel = Level.ALERT;
       includeStack = false;
-      isEnabled = true;
+      isEnabled2 = true;
     }
   });
 
@@ -25298,6 +25298,66 @@ var ZenFSConfig = (() => {
     writeVersion: () => writeVersion
   });
 
+  // node_modules/@richard432/localstorage-logger/dist/index.mjs
+  var PREFIX = "debug:";
+  function hasLocalStorage() {
+    try {
+      return typeof localStorage !== "undefined" && localStorage !== null;
+    } catch {
+      return false;
+    }
+  }
+  function getProcessEnv() {
+    try {
+      if (typeof process !== "undefined" && process.env !== void 0) {
+        return process.env;
+      }
+    } catch {
+    }
+    return null;
+  }
+  function moduleToEnvKey(module) {
+    return "DEBUG_" + module.replace(/[:-]/g, "_").toUpperCase();
+  }
+  function isEnabled(module) {
+    const key = `${PREFIX}${module}`;
+    if (hasLocalStorage()) {
+      const val = localStorage.getItem(key);
+      if (val === null) {
+        localStorage.setItem(key, "1");
+        return true;
+      }
+      return val === "1";
+    }
+    const env = getProcessEnv();
+    if (env) {
+      const envKey = moduleToEnvKey(module);
+      const val = env[envKey];
+      if (val === void 0) return true;
+      return val === "1";
+    }
+    return true;
+  }
+  function createLogger(module) {
+    return {
+      log(...args) {
+        if (isEnabled(module)) {
+          console.log(`[${module}]`, ...args);
+        }
+      },
+      warn(...args) {
+        if (isEnabled(module)) {
+          console.warn(`[${module}]`, ...args);
+        }
+      },
+      error(...args) {
+        if (isEnabled(module)) {
+          console.error(`[${module}]`, ...args);
+        }
+      }
+    };
+  }
+
   // node_modules/zen-fs-sync/dist/index.mjs
   function isDirectory(stat5) {
     return stat5.mode !== void 0 && (stat5.mode & 16384) === 16384;
@@ -25310,16 +25370,12 @@ var ZenFSConfig = (() => {
     SyncDirection2["BiDirectional"] = "bi-directional";
     return SyncDirection2;
   })(SyncDirection || {});
-  var enabled = false;
-  var tagFilter = /* @__PURE__ */ new Set();
-  function createLogger(tag) {
-    return (...args) => {
-      if (!enabled) return;
-      if (tagFilter.size > 0 && !tagFilter.has(tag)) return;
-      console.log(`[zen-fs-sync:${tag}]`, ...args);
-    };
+  var MODULE_PREFIX = "zen-fs-sync";
+  function createLogger2(tag) {
+    const logger = createLogger(`${MODULE_PREFIX}:${tag}`);
+    return (...args) => logger.log(...args);
   }
-  var log = createLogger("detector");
+  var log = createLogger2("detector");
   function normalizePath(p) {
     let s = p.replace(/\\/g, "/");
     if (s.length > 1 && s.endsWith("/")) {
@@ -25367,6 +25423,11 @@ var ZenFSConfig = (() => {
     );
     return regex.test(str);
   }
+  function describeFs(fs) {
+    if (fs.backendName) return fs.backendName;
+    const ctorName = fs.constructor?.name;
+    return ctorName && ctorName !== "Object" ? ctorName : "unknown";
+  }
   async function walkFiles(fs, root, filter) {
     const results = [];
     const normalizedRoot = normalizePath(root);
@@ -25392,6 +25453,18 @@ var ZenFSConfig = (() => {
           await visit(fullPath);
         } else if (isFile(stat5)) {
           if (!isPathAllowed(relPath, filter)) continue;
+          if (relPath.endsWith(".mtime")) {
+            console.warn(
+              `[zen-fs-sync] mtime sidecar leaked from backend "${describeFs(fs)}" - its readdir()/createSnapshot() must filter sidecars; skipping ${fullPath} (rel ${relPath})`
+            );
+            continue;
+          }
+          if (relPath === "/.keep" || relPath.endsWith("/.keep")) {
+            console.warn(
+              `[zen-fs-sync] '.keep' placeholder leaked from backend "${describeFs(fs)}" - its readdir() must filter the internal placeholder; skipping ${fullPath} (rel ${relPath})`
+            );
+            continue;
+          }
           results.push(relPath);
         }
       }
@@ -25399,13 +25472,48 @@ var ZenFSConfig = (() => {
     await visit(normalizedRoot);
     return results;
   }
+  async function collectDirectories(fs, root, filter) {
+    const results = [];
+    const normalizedRoot = normalizePath(root);
+    async function visit(dir) {
+      let entries2;
+      try {
+        entries2 = await fs.readdir(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries2) {
+        if (entry === ".zenfs-sync") continue;
+        const fullPath = resolvePath(dir, entry);
+        let relPath = fullPath.slice(normalizedRoot.length) || "/";
+        if (!relPath.startsWith("/")) relPath = "/" + relPath;
+        let stat5;
+        try {
+          stat5 = await fs.stat(fullPath);
+        } catch {
+          continue;
+        }
+        if (isDirectory(stat5)) {
+          if (isPathAllowed(relPath, filter)) results.push(relPath);
+          await visit(fullPath);
+        }
+      }
+    }
+    await visit(normalizedRoot);
+    return results;
+  }
   async function buildSnapshot(fs, root, filter) {
     const normalizedRoot = normalizePath(root);
     const fsName = fs.backendName || "unknown";
     try {
       await fs.readdir(normalizedRoot);
-    } catch {
-      console.warn(`[zen-fs-sync] buildSnapshot(${fsName}): unreachable, returning null`);
+    } catch (err2) {
+      const e = err2;
+      if (e && (e.name === "DirectoryNotFoundError" || e.code === "ENOENT")) {
+        log(`buildSnapshot(${fsName}): root missing, treating as empty`);
+        return /* @__PURE__ */ new Map();
+      }
+      log(`buildSnapshot(${fsName}): unreachable, returning null`);
       return null;
     }
     const files = await walkFiles(fs, root, filter);
@@ -25466,7 +25574,7 @@ var ZenFSConfig = (() => {
   }
   function diffSnapshots(source, target) {
     if (source === null || target === null) {
-      console.log(`[zen-fs-sync] diffSnapshots: one side is null (unreachable) \u2014 skipping to prevent false deletions`);
+      log(`diffSnapshots: one side is null (unreachable) \u2014 skipping to prevent false deletions`);
       return [];
     }
     const changes = [];
@@ -25492,7 +25600,7 @@ var ZenFSConfig = (() => {
     }
     return changes;
   }
-  var log2 = createLogger("detector");
+  var log2 = createLogger2("detector");
   var IncrementalDetector = class {
     async detect(source, target, root, prevSnapshots, filter) {
       if (!prevSnapshots || prevSnapshots.size === 0) {
@@ -25559,7 +25667,7 @@ var ZenFSConfig = (() => {
       }
     }
   };
-  var log3 = createLogger("sync");
+  var log3 = createLogger2("sync");
   var SyncPair = class {
     constructor(source, target, options = {}, syncRoot = "/") {
       __publicField(this, "syncRoot");
@@ -25572,6 +25680,7 @@ var ZenFSConfig = (() => {
       __publicField(this, "resolver");
       __publicField(this, "state", "idle");
       __publicField(this, "lastResult");
+      __publicField(this, "lastError");
       __publicField(this, "lastCheckTime");
       __publicField(this, "totalSyncs", 0);
       // 轮询定时器列表（远程 shouldSync 轮询，或两端都不支持变更检测时的兜底轮询）
@@ -25632,7 +25741,7 @@ var ZenFSConfig = (() => {
           try {
             await this.options.preSyncHook();
           } catch (err2) {
-            console.warn(`[zen-fs-sync] preSyncHook error pairId=${this.pairId}`, err2);
+            log3(`[zen-fs-sync] preSyncHook error pairId=${this.pairId}`, err2);
           } finally {
             this.hookInProgress = false;
           }
@@ -25647,18 +25756,21 @@ var ZenFSConfig = (() => {
           try {
             await this.options.postSyncHook();
           } catch (err2) {
-            console.warn(`[zen-fs-sync] postSyncHook error pairId=${this.pairId}`, err2);
+            log3(`[zen-fs-sync] postSyncHook error pairId=${this.pairId}`, err2);
           } finally {
             this.hookInProgress = false;
           }
         }
         result.durationMs = Date.now() - startTime;
         this.lastResult = result;
+        if (result.errors && result.errors.length > 0) {
+          this.lastError = { message: result.errors[0].message, timestamp: result.timestamp };
+        }
         this.totalSyncs++;
         this.state = this.pollTimers.length > 0 ? "watching" : "idle";
         const hasActivity = result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0 || result.conflicts.length > 0;
         if (hasActivity) {
-          console.log(`[zen-fs-sync] sync pairId=${this.pairId} +${result.filesCreated}/~${result.filesUpdated}/-${result.filesDeleted} skip:${result.filesSkipped} conflicts:${result.conflicts.length} ${result.durationMs}ms`);
+          log3(`[zen-fs-sync] sync pairId=${this.pairId} +${result.filesCreated}/~${result.filesUpdated}/-${result.filesDeleted} skip:${result.filesSkipped} conflicts:${result.conflicts.length} ${result.durationMs}ms`);
         }
         this.emit({
           type: "sync:end",
@@ -25669,7 +25781,8 @@ var ZenFSConfig = (() => {
         return result;
       } catch (error) {
         this.state = this.pollTimers.length > 0 ? "watching" : "idle";
-        console.error(`[zen-fs-sync] sync ERROR pairId=${this.pairId}`, error);
+        this.lastError = { message: error instanceof Error ? error.message : String(error), timestamp: Date.now() };
+        log3(`[zen-fs-sync] sync ERROR pairId=${this.pairId}`, error);
         this.emit({
           type: "sync:error",
           pairId: this.pairId,
@@ -25760,6 +25873,7 @@ var ZenFSConfig = (() => {
         state: this.state,
         lastResult: this.lastResult,
         lastCheckTime: this.lastCheckTime,
+        lastError: this.lastError,
         // 是否正在 watch：有轮询定时器或处于 Watching 状态
         watching: this.pollTimers.length > 0 || this.state === "watching",
         totalSyncs: this.totalSyncs
@@ -25814,7 +25928,7 @@ var ZenFSConfig = (() => {
         this.options.filter
       );
       if (changes.length > 0) {
-        console.log(`[zen-fs-sync] syncOneWay START direction=${directionLabel} changes=${changes.length}`);
+        log3(`[zen-fs-sync] syncOneWay START direction=${directionLabel} changes=${changes.length}`);
       }
       const newSnap = await this.getSnapshot(src);
       if (newSnap !== null) {
@@ -25825,6 +25939,7 @@ var ZenFSConfig = (() => {
       let filesDeleted = 0;
       let filesSkipped = 0;
       const conflicts = [];
+      const errors = [];
       for (const change of changes) {
         const srcPath = resolvePath(this.root, change.path);
         const tgtPath = resolvePath(this.root, change.path);
@@ -25868,37 +25983,40 @@ var ZenFSConfig = (() => {
               try {
                 const tgtContent = await tgt.readFile(tgtPath, "utf-8");
                 if (srcContent === tgtContent) {
-                  console.log(`[zen-fs-sync] WRITE SKIP (content identical) ${change.path}`);
+                  log3(`[zen-fs-sync] WRITE SKIP (content identical) ${change.path}`);
                   filesSkipped++;
                   break;
                 }
               } catch {
               }
-              console.log(`[zen-fs-sync] WRITE ${change.type} [${directionLabel}] ${srcPath} \u2192 ${tgtPath} (${srcContent.length} chars)`);
+              log3(`[zen-fs-sync] WRITE ${change.type} [${directionLabel}] ${srcPath} \u2192 ${tgtPath} (${srcContent.length} chars)`);
               await ensureDir(tgt, tgtPath.substring(0, tgtPath.lastIndexOf("/")));
               await tgt.writeFile(tgtPath, srcContent);
               if (isCreated) filesCreated++;
               else filesUpdated++;
             } catch (err2) {
-              console.error(`[zen-fs-sync] WRITE FAIL ${change.type} [${directionLabel}] ${srcPath} \u2192 ${tgtPath}:`, err2);
+              log3(`[zen-fs-sync] WRITE FAIL ${change.type} [${directionLabel}] ${srcPath} \u2192 ${tgtPath}:`, err2);
+              errors.push({ path: change.path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
             break;
           }
           case "deleted": {
             try {
-              console.log(`[zen-fs-sync] DELETE [${directionLabel}] ${tgtPath}`);
-              console.log(`[SYNC-TRACE] oneway DELETE \u2192 tgt.unlink(${tgtPath}) \u2014 NO exists() check before unlink`);
+              log3(`[zen-fs-sync] DELETE [${directionLabel}] ${tgtPath}`);
+              log3(`[SYNC-TRACE] oneway DELETE \u2192 tgt.unlink(${tgtPath}) \u2014 NO exists() check before unlink`);
               await tgt.unlink(tgtPath);
               filesDeleted++;
             } catch (err2) {
-              console.warn(`[zen-fs-sync] DELETE SKIP [${directionLabel}] ${tgtPath}:`, err2);
+              log3(`[zen-fs-sync] DELETE SKIP [${directionLabel}] ${tgtPath}:`, err2);
+              errors.push({ path: change.path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
             break;
           }
         }
       }
+      await this.preserveDirectories(src, tgt);
       return {
         pairId: this.pairId,
         direction: this.options.direction,
@@ -25908,6 +26026,7 @@ var ZenFSConfig = (() => {
         filesDeleted,
         filesSkipped,
         conflicts,
+        errors,
         changes,
         durationMs: 0
         // 由 sync() 方法填充
@@ -25920,7 +26039,7 @@ var ZenFSConfig = (() => {
         this.getSnapshot(this.target)
       ]);
       if (srcSnap === null || tgtSnap === null) {
-        console.log(`[zen-fs-sync] syncBidirectional SKIP (one side unreachable)`);
+        log3(`[zen-fs-sync] syncBidirectional SKIP (one side unreachable)`);
         return {
           pairId: this.pairId,
           direction: "bi-directional",
@@ -25957,13 +26076,14 @@ var ZenFSConfig = (() => {
       this.prevTgtSnap = tgtSnap;
       const srcPaths = Array.from(srcSnap.keys()).sort();
       const tgtPaths = Array.from(tgtSnap.keys()).sort();
-      console.log(`[zen-fs-sync] syncBidirectional comparing source=${srcPaths.length} target=${tgtPaths.length}`);
+      log3(`[zen-fs-sync] syncBidirectional comparing source=${srcPaths.length} target=${tgtPaths.length}`);
       let filesCreated = 0;
       let filesUpdated = 0;
       let filesDeleted = 0;
       let filesSkipped = 0;
       const conflicts = [];
       const changes = [];
+      const errors = [];
       const allPaths = /* @__PURE__ */ new Set([...srcSnap.keys(), ...tgtSnap.keys()]);
       for (const path of allPaths) {
         const srcEntry = srcSnap.get(path);
@@ -25972,13 +26092,14 @@ var ZenFSConfig = (() => {
           if (oldPrevSrcSnap?.has(path)) {
             try {
               const fullPath = resolvePath(this.root, path);
-              console.log(`[zen-fs-sync] DELETE (src deleted) target ${path}`);
-              console.log(`[SYNC-TRACE] bidirectional DELETE (src deleted) \u2192 target.unlink(${fullPath}) \u2014 NO exists() check before unlink`);
+              log3(`[zen-fs-sync] DELETE (src deleted) target ${path}`);
+              log3(`[SYNC-TRACE] bidirectional DELETE (src deleted) \u2192 target.unlink(${fullPath}) \u2014 NO exists() check before unlink`);
               await this.target.unlink(fullPath);
               filesDeleted++;
               changes.push({ path, type: "deleted", targetSnapshot: tgtEntry });
             } catch (err2) {
-              console.warn(`[zen-fs-sync] DELETE SKIP (src deleted) target ${path}:`, err2);
+              log3(`[zen-fs-sync] DELETE SKIP (src deleted) target ${path}:`, err2);
+              errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
           } else {
@@ -25987,12 +26108,13 @@ var ZenFSConfig = (() => {
               if (wrote) {
                 filesCreated++;
                 changes.push({ path, type: "created", sourceSnapshot: tgtEntry });
-                console.log(`[zen-fs-sync] COPY target\u2192source ${path}`);
+                log3(`[zen-fs-sync] COPY target\u2192source ${path}`);
               } else {
                 filesSkipped++;
               }
             } catch (err2) {
-              console.error(`[zen-fs-sync] COPY FAIL target\u2192source ${path}:`, err2);
+              log3(`[zen-fs-sync] COPY FAIL target\u2192source ${path}:`, err2);
+              errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
           }
@@ -26000,13 +26122,14 @@ var ZenFSConfig = (() => {
           if (oldPrevTgtSnap?.has(path)) {
             try {
               const fullPath = resolvePath(this.root, path);
-              console.log(`[zen-fs-sync] DELETE (tgt deleted) source ${path}`);
-              console.log(`[SYNC-TRACE] bidirectional DELETE (tgt deleted) \u2192 source.unlink(${fullPath}) \u2014 NO exists() check before unlink`);
+              log3(`[zen-fs-sync] DELETE (tgt deleted) source ${path}`);
+              log3(`[SYNC-TRACE] bidirectional DELETE (tgt deleted) \u2192 source.unlink(${fullPath}) \u2014 NO exists() check before unlink`);
               await this.source.unlink(fullPath);
               filesDeleted++;
               changes.push({ path, type: "deleted", sourceSnapshot: srcEntry });
             } catch (err2) {
-              console.warn(`[zen-fs-sync] DELETE SKIP (tgt deleted) source ${path}:`, err2);
+              log3(`[zen-fs-sync] DELETE SKIP (tgt deleted) source ${path}:`, err2);
+              errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
           } else {
@@ -26015,12 +26138,13 @@ var ZenFSConfig = (() => {
               if (wrote) {
                 filesCreated++;
                 changes.push({ path, type: "created", sourceSnapshot: srcEntry });
-                console.log(`[zen-fs-sync] COPY source\u2192target ${path}`);
+                log3(`[zen-fs-sync] COPY source\u2192target ${path}`);
               } else {
                 filesSkipped++;
               }
             } catch (err2) {
-              console.error(`[zen-fs-sync] COPY FAIL source\u2192target ${path}:`, err2);
+              log3(`[zen-fs-sync] COPY FAIL source\u2192target ${path}:`, err2);
+              errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
             }
           }
@@ -26036,15 +26160,17 @@ var ZenFSConfig = (() => {
               srcContent = await this.source.readFile(fullPath, "utf-8");
               tgtContent = await this.target.readFile(fullPath, "utf-8");
             } catch (err2) {
-              console.error(`[zen-fs-sync] CONTENT READ FAIL ${path}:`, err2);
+              log3(`[zen-fs-sync] CONTENT READ FAIL ${path}:`, err2);
+              errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
               filesSkipped++;
               continue;
             }
             if (srcContent === tgtContent) {
               const oldestMtime = Math.min(srcEntry.mtimeMs, tgtEntry.mtimeMs);
+              const keptOn = srcEntry.mtimeMs <= tgtEntry.mtimeMs ? "src" : "tgt";
               await this.normalizeMtimeBoth(path, srcContent, oldestMtime);
               filesSkipped++;
-              console.log(`[zen-fs-sync] MTIME NORMALIZE ${path} \u2192 mtime=${oldestMtime} (content identical, was src=${srcEntry.mtimeMs} tgt=${tgtEntry.mtimeMs})`);
+              log3(`[zen-fs-sync] MTIME NORMALIZE ${path} \u2192 mtime=${oldestMtime} (content identical; src=${srcEntry.mtimeMs} tgt=${tgtEntry.mtimeMs}; kept=oldest(${keptOn}); real mtime stored in sidecar .${path}.mtime)`);
             } else {
               const newerIsSource = srcEntry.mtimeMs > tgtEntry.mtimeMs;
               const fromFs = newerIsSource ? this.source : this.target;
@@ -26055,12 +26181,13 @@ var ZenFSConfig = (() => {
                 if (wrote) {
                   filesUpdated++;
                   changes.push({ path, type: "modified", sourceSnapshot: newerIsSource ? srcEntry : tgtEntry, targetSnapshot: newerIsSource ? tgtEntry : srcEntry });
-                  console.log(`[zen-fs-sync] UPDATE ${fromLabel} ${path} (mtime=${newerIsSource ? srcEntry.mtimeMs : tgtEntry.mtimeMs} > ${newerIsSource ? tgtEntry.mtimeMs : srcEntry.mtimeMs})`);
+                  log3(`[zen-fs-sync] UPDATE ${fromLabel} ${path} (mtime=${newerIsSource ? srcEntry.mtimeMs : tgtEntry.mtimeMs} > ${newerIsSource ? tgtEntry.mtimeMs : srcEntry.mtimeMs})`);
                 } else {
                   filesSkipped++;
                 }
               } catch (err2) {
-                console.error(`[zen-fs-sync] UPDATE FAIL ${fromLabel} ${path}:`, err2);
+                log3(`[zen-fs-sync] UPDATE FAIL ${fromLabel} ${path}:`, err2);
+                errors.push({ path, message: err2 instanceof Error ? err2.message : String(err2) });
                 filesSkipped++;
               }
             }
@@ -26086,12 +26213,14 @@ var ZenFSConfig = (() => {
             await this.writeFileBoth(path, resolved.content);
             filesUpdated++;
             changes.push({ path, type: "modified", sourceSnapshot: { ...srcEntry, mtimeMs: Date.now() }, targetSnapshot: srcEntry });
-            console.log(`[zen-fs-sync] CONFLICT ${path} resolved=${resolved.strategy}`);
+            log3(`[zen-fs-sync] CONFLICT ${path} resolved=${resolved.strategy}`);
           }
         }
       }
+      await this.preserveDirectories(this.source, this.target);
+      await this.preserveDirectories(this.target, this.source);
       const durationMs = Date.now() - startTime;
-      console.log(`[zen-fs-sync] syncBidirectional END pairId=${this.pairId} +${filesCreated}/~${filesUpdated}/-${filesDeleted} ${durationMs}ms`);
+      log3(`[zen-fs-sync] syncBidirectional END pairId=${this.pairId} +${filesCreated}/~${filesUpdated}/-${filesDeleted} ${durationMs}ms`);
       return {
         pairId: this.pairId,
         direction: "bi-directional",
@@ -26101,6 +26230,7 @@ var ZenFSConfig = (() => {
         filesDeleted,
         filesSkipped,
         conflicts,
+        errors,
         changes,
         durationMs
       };
@@ -26118,6 +26248,28 @@ var ZenFSConfig = (() => {
       }
       return buildSnapshot(fs, this.root, this.options.filter);
     }
+    /**
+     * Preserve empty directories across backends (zen-fs-sync/docs/SyncableFS.md §2).
+     *
+     * A backend that cannot store empty directories (Git, RemoteStorage) keeps a
+     * directory alive with an internal `.keep` placeholder that is hidden from
+     * callers. Because the sync snapshot is file-based, empty directories are not
+     * represented, so the sync engine must explicitly `mkdir` each source
+     * directory on the target. The target's own `mkdir` then produces its own
+     * (hidden) placeholder. Best-effort: failures are logged, never thrown.
+     */
+    async preserveDirectories(source, target) {
+      try {
+        const dirs = await collectDirectories(source, this.root, this.options.filter);
+        for (const relDir of dirs) {
+          if (relDir === "/") continue;
+          const fullDir = resolvePath(this.root, relDir);
+          await ensureDir(target, fullDir);
+        }
+      } catch (err2) {
+        log3(`[zen-fs-sync] preserveDirectories FAIL: ${err2}`);
+      }
+    }
     /**
      * Compare two snapshots for equality (same paths, same size, same mtime).
      * Returns true if they are identical, false otherwise.
@@ -26682,70 +26834,10 @@ var ZenFSConfig = (() => {
   init_backend_registry();
   init_dist4();
 
-  // node_modules/@richard432/localstorage-logger/dist/index.mjs
-  var PREFIX = "debug:";
-  function hasLocalStorage() {
-    try {
-      return typeof localStorage !== "undefined" && localStorage !== null;
-    } catch {
-      return false;
-    }
-  }
-  function getProcessEnv() {
-    try {
-      if (typeof process !== "undefined" && process.env !== void 0) {
-        return process.env;
-      }
-    } catch {
-    }
-    return null;
-  }
-  function moduleToEnvKey(module) {
-    return "DEBUG_" + module.replace(/[:-]/g, "_").toUpperCase();
-  }
-  function isEnabled2(module) {
-    const key = `${PREFIX}${module}`;
-    if (hasLocalStorage()) {
-      const val = localStorage.getItem(key);
-      if (val === null) {
-        localStorage.setItem(key, "1");
-        return true;
-      }
-      return val === "1";
-    }
-    const env = getProcessEnv();
-    if (env) {
-      const envKey = moduleToEnvKey(module);
-      const val = env[envKey];
-      if (val === void 0) return true;
-      return val === "1";
-    }
-    return true;
-  }
-  function createLogger2(module) {
-    return {
-      log(...args) {
-        if (isEnabled2(module)) {
-          console.log(`[${module}]`, ...args);
-        }
-      },
-      warn(...args) {
-        if (isEnabled2(module)) {
-          console.warn(`[${module}]`, ...args);
-        }
-      },
-      error(...args) {
-        if (isEnabled2(module)) {
-          console.error(`[${module}]`, ...args);
-        }
-      }
-    };
-  }
-
   // src/logger.ts
-  var MODULE_PREFIX = "zen-fs-config";
+  var MODULE_PREFIX2 = "zen-fs-config";
   function createLogger3(prefix) {
-    const logger = createLogger2(`${MODULE_PREFIX}:${prefix}`);
+    const logger = createLogger(`${MODULE_PREFIX2}:${prefix}`);
     return (...args) => logger.log(...args);
   }
 
@@ -27351,7 +27443,7 @@ var ZenFSConfig = (() => {
   }
 
   // src/config-repo.ts
-  var log6 = createLogger2("zen-fs-config:config-repo");
+  var log6 = createLogger("zen-fs-config:config-repo");
   var META_DIR = "/.meta";
   var GROUP_TYPE_FILE = `${META_DIR}/group-type`;
   var BACKENDS_FILE = `${META_DIR}/backends.json`;
@@ -28834,7 +28926,11 @@ var ZenFSConfig = (() => {
     }
     async init() {
       try {
-        const localPrimary = await resolveLocalPrimary(this.appId, "data");
+        const localPrimary = await resolveLocalPrimary(
+          this.appId,
+          "data",
+          this.groupId === "default" ? {} : { idbStoreName: `zen-fs-config-data-${this.appId}-${this.groupId}` }
+        );
         this.localFS = await createBackend(localPrimary);
       } catch {
         throw new Error(`Failed to create local primary for data group "${this.groupId}"`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-fs-config",
-  "version": "0.5.42",
+  "version": "0.5.44",
   "description": "Distributed config management library built on ZenFS, zen-fs-cache, and zen-fs-sync",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -85,6 +85,6 @@
     "typescript": "^5.9.3",
     "vitest": "^1.6.1",
     "zen-fs-cache": "^1.0.6",
-    "zen-fs-sync": "^0.4.9"
+    "zen-fs-sync": "^0.4.17"
   }
 }