@anfenn/zync 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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 });
@@ -17,12 +20,269 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/.pnpm/idb@8.0.3/node_modules/idb/build/index.js
+var build_exports = {};
+__export(build_exports, {
+  deleteDB: () => deleteDB,
+  openDB: () => openDB,
+  unwrap: () => unwrap,
+  wrap: () => wrap
+});
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event.newVersion,
+      event
+    ));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {
+  });
+  return openPromise;
+}
+function deleteDB(name, { blocked } = {}) {
+  const request = indexedDB.deleteDatabase(name);
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event
+    ));
+  }
+  return wrap(request).then(() => void 0);
+}
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
+  ) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+async function* iterate(...args) {
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor)
+    return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+var instanceOfAny, idbProxyableTypes, cursorAdvanceMethods, transactionDoneMap, transformCache, reverseTransformCache, idbProxyTraps, unwrap, readMethods, writeMethods, cachedMethods, advanceMethodProps, methodMap, advanceResults, ittrProxiedCursorToOriginalProxy, cursorIteratorTraps;
+var init_build = __esm({
+  "node_modules/.pnpm/idb@8.0.3/node_modules/idb/build/index.js"() {
+    "use strict";
+    instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+    transactionDoneMap = /* @__PURE__ */ new WeakMap();
+    transformCache = /* @__PURE__ */ new WeakMap();
+    reverseTransformCache = /* @__PURE__ */ new WeakMap();
+    idbProxyTraps = {
+      get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+          if (prop === "done")
+            return transactionDoneMap.get(target);
+          if (prop === "store") {
+            return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+          }
+        }
+        return wrap(target[prop]);
+      },
+      set(target, prop, value) {
+        target[prop] = value;
+        return true;
+      },
+      has(target, prop) {
+        if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+          return true;
+        }
+        return prop in target;
+      }
+    };
+    unwrap = (value) => reverseTransformCache.get(value);
+    readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+    writeMethods = ["put", "add", "delete", "clear"];
+    cachedMethods = /* @__PURE__ */ new Map();
+    replaceTraps((oldTraps) => ({
+      ...oldTraps,
+      get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+      has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+    }));
+    advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+    methodMap = {};
+    advanceResults = /* @__PURE__ */ new WeakMap();
+    ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap();
+    cursorIteratorTraps = {
+      get(target, prop) {
+        if (!advanceMethodProps.includes(prop))
+          return target[prop];
+        let cachedFunc = methodMap[prop];
+        if (!cachedFunc) {
+          cachedFunc = methodMap[prop] = function(...args) {
+            advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+          };
+        }
+        return cachedFunc;
+      }
+    };
+    replaceTraps((oldTraps) => ({
+      ...oldTraps,
+      get(target, prop, receiver) {
+        if (isIteratorProp(target, prop))
+          return iterate;
+        return oldTraps.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+      }
+    }));
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   SyncAction: () => SyncAction,
   createIndexedDBStorage: () => createIndexedDBStorage,
-  createStoreWithSync: () => createStoreWithSync,
+  createWithSync: () => createWithSync,
   nextLocalId: () => nextLocalId,
   persistWithSync: () => persistWithSync
 });
@@ -30,27 +290,247 @@ module.exports = __toCommonJS(index_exports);
 var import_zustand = require("zustand");
 var import_middleware = require("zustand/middleware");
 
+// src/logger.ts
+function newLogger(base, min) {
+  const order = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    none: 100
+  };
+  const threshold = order[min];
+  const enabled = (lvl) => order[lvl] >= threshold;
+  return {
+    debug: (...a) => enabled("debug") && base.debug?.(...a),
+    info: (...a) => enabled("info") && base.info?.(...a),
+    warn: (...a) => enabled("warn") && base.warn?.(...a),
+    error: (...a) => enabled("error") && base.error?.(...a)
+  };
+}
+
+// src/helpers.ts
+function nextLocalId() {
+  return crypto.randomUUID();
+}
+function orderFor(a) {
+  switch (a) {
+    case "createOrUpdate" /* CreateOrUpdate */:
+      return 1;
+    case "remove" /* Remove */:
+      return 2;
+  }
+}
+function omitSyncFields(item, fields) {
+  const result = { ...item };
+  for (const k of fields) delete result[k];
+  return result;
+}
+function samePendingVersion(get, stateKey, localId, version) {
+  const q = get().syncState.pendingChanges || [];
+  const curChange = q.find((p) => p.localId === localId && p.stateKey === stateKey);
+  return curChange?.version === version;
+}
+function removeFromPendingChanges(set, localId, stateKey) {
+  set((s) => {
+    const queue = (s.syncState.pendingChanges || []).filter((p) => !(p.localId === localId && p.stateKey === stateKey));
+    return {
+      syncState: {
+        ...s.syncState || {},
+        pendingChanges: queue
+      }
+    };
+  });
+}
+function findApi(stateKey, syncApi) {
+  const api = syncApi[stateKey];
+  if (!api || !api.add || !api.update || !api.remove || !api.list || !api.firstLoad) {
+    throw new Error(`Missing API function(s) for state key: ${stateKey}.`);
+  }
+  return api;
+}
+
+// src/pull.ts
+async function pull(set, get, stateKey, api, logger) {
+  const lastPulled = get().syncState.lastPulled || {};
+  const lastPulledAt = new Date(lastPulled[stateKey] || /* @__PURE__ */ new Date(0));
+  logger.debug(`[Zync] pull:start stateKey=${stateKey} since=${lastPulledAt.toISOString()}`);
+  const serverData = await api.list(lastPulledAt);
+  if (!serverData?.length) return;
+  let newest = lastPulledAt;
+  set((state) => {
+    const pendingChanges = state.syncState.pendingChanges || [];
+    const localItems = state[stateKey] || [];
+    let nextItems = [...localItems];
+    const localById = new Map(localItems.filter((l) => l.id).map((l) => [l.id, l]));
+    const pendingRemovalById = new Set(pendingChanges.filter((p) => p.stateKey === stateKey && p.action === "remove" /* Remove */).map((p) => p.id));
+    for (const remote of serverData) {
+      const remoteUpdated = new Date(remote.updated_at);
+      if (remoteUpdated > newest) newest = remoteUpdated;
+      if (pendingRemovalById.has(remote.id)) {
+        logger.debug(`[Zync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
+        continue;
+      }
+      const localItem = localById.get(remote.id);
+      if (remote.deleted) {
+        if (localItem) {
+          nextItems = nextItems.filter((i) => i.id !== remote.id);
+          logger.debug(`[Zync] pull:remove stateKey=${stateKey} id=${remote.id}`);
+        }
+        continue;
+      }
+      const pending = localItem && pendingChanges.some((p) => p.stateKey === stateKey && p.localId === localItem._localId);
+      if (localItem && !pending) {
+        const merged = {
+          ...localItem,
+          ...remote,
+          _localId: localItem._localId
+        };
+        nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
+        logger.debug(`[Zync] pull:merge stateKey=${stateKey} id=${remote.id}`);
+      } else if (!localItem) {
+        nextItems = [...nextItems, { ...remote, _localId: nextLocalId() }];
+        logger.debug(`[Zync] pull:add stateKey=${stateKey} id=${remote.id}`);
+      }
+    }
+    return {
+      [stateKey]: nextItems,
+      syncState: {
+        ...state.syncState || {},
+        lastPulled: {
+          ...state.syncState.lastPulled || {},
+          [stateKey]: newest.toISOString()
+        }
+      }
+    };
+  });
+}
+
+// src/push.ts
+var SYNC_FIELDS = ["id", "_localId", "updated_at", "deleted"];
+async function pushOne(set, get, change, api, logger, queueToSync, missingStrategy, onMissingRemoteRecordDuringUpdate, onAfterRemoteAdd) {
+  logger.debug(`[Zync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
+  const { action, stateKey, localId, id, version } = change;
+  switch (action) {
+    case "remove" /* Remove */:
+      await api.remove(id);
+      logger.debug(`[Zync] push:remove:success ${stateKey} ${localId} ${id}`);
+      removeFromPendingChanges(set, localId, stateKey);
+      break;
+    case "createOrUpdate" /* CreateOrUpdate */: {
+      const state = get();
+      const items = state[stateKey] || [];
+      const item = items.find((i) => i._localId === localId);
+      if (!item) {
+        logger.warn(`[Zync] push:${action}:no-local-item`, {
+          stateKey,
+          localId
+        });
+        removeFromPendingChanges(set, localId, stateKey);
+        return;
+      }
+      const omittedItem = omitSyncFields(item, SYNC_FIELDS);
+      if (item.id) {
+        const changed = await api.update(item.id, omittedItem);
+        if (changed) {
+          logger.debug("[Zync] push:update:success", {
+            stateKey,
+            localId,
+            id: item.id
+          });
+          if (samePendingVersion(get, stateKey, localId, version)) {
+            removeFromPendingChanges(set, localId, stateKey);
+          }
+          return;
+        } else {
+          logger.warn("[Zync] push:update:missingRemote", {
+            stateKey,
+            localId,
+            id: item.id
+          });
+          switch (missingStrategy) {
+            case "deleteLocalRecord":
+              set((s) => ({
+                [stateKey]: (s[stateKey] || []).filter((i) => i._localId !== localId)
+              }));
+              break;
+            case "insertNewRemoteRecord": {
+              omittedItem._localId = crypto.randomUUID();
+              omittedItem.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+              set((s) => ({
+                [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? omittedItem : i)
+              }));
+              queueToSync("createOrUpdate" /* CreateOrUpdate */, stateKey, omittedItem._localId);
+              break;
+            }
+          }
+          removeFromPendingChanges(set, localId, stateKey);
+          onMissingRemoteRecordDuringUpdate?.(missingStrategy, omittedItem, omittedItem._localId);
+        }
+        return;
+      }
+      const result = await api.add(omittedItem);
+      if (result) {
+        logger.debug("[Zync] push:create:success", {
+          stateKey,
+          localId,
+          id: result.id
+        });
+        set((s) => ({
+          [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? { ...i, ...result } : i)
+        }));
+        if (samePendingVersion(get, stateKey, localId, version)) {
+          removeFromPendingChanges(set, localId, stateKey);
+        }
+        onAfterRemoteAdd?.(set, get, queueToSync, stateKey, {
+          ...item,
+          ...result
+        });
+      } else {
+        logger.warn("[Zync] push:create:no-result", {
+          stateKey,
+          localId
+        });
+        if (samePendingVersion(get, stateKey, localId, version)) {
+          removeFromPendingChanges(set, localId, stateKey);
+        }
+      }
+      break;
+    }
+  }
+}
+
 // src/indexedDBStorage.ts
-var import_idb = require("idb");
 function createIndexedDBStorage(options) {
   const dbName = options.dbName;
   const storeName = options.storeName;
-  let dbPromise = (0, import_idb.openDB)(dbName, 1, {
-    upgrade(db) {
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
+  let dbPromise = null;
+  async function initDB() {
+    if (dbPromise) return dbPromise;
+    try {
+      const idb = await Promise.resolve().then(() => (init_build(), build_exports));
+      dbPromise = idb.openDB(dbName, 1, {
+        upgrade(db) {
+          if (!db.objectStoreNames.contains(storeName)) {
+            db.createObjectStore(storeName);
+          }
+        }
+      });
+      return dbPromise;
+    } catch (_e) {
+      throw new Error('Missing optional dependency "idb". Install it to use IndexedDB storage: npm install idb');
     }
-  });
+  }
   async function ensureStore() {
-    const db = await dbPromise;
+    const db = await initDB();
     if (db.objectStoreNames.contains(storeName)) return;
     const nextVersion = (db.version || 0) + 1;
     try {
       db.close();
-    } catch (e) {
+    } catch (_e) {
     }
-    dbPromise = (0, import_idb.openDB)(dbName, nextVersion, {
+    const idb = await Promise.resolve().then(() => (init_build(), build_exports));
+    dbPromise = idb.openDB(dbName, nextVersion, {
       upgrade(upg) {
         if (!upg.objectStoreNames.contains(storeName)) upg.createObjectStore(storeName);
       }
@@ -59,13 +539,13 @@ function createIndexedDBStorage(options) {
   }
   async function withRetry(fn) {
     try {
-      const db = await dbPromise;
+      const db = await initDB();
       return await fn(db);
     } catch (err) {
       const msg = String(err && err.message ? err.message : err);
       if (err && (err.name === "NotFoundError" || /objectStore/i.test(msg))) {
         await ensureStore();
-        const db2 = await dbPromise;
+        const db2 = await initDB();
         return await fn(db2);
       }
       throw err;
@@ -76,19 +556,16 @@ function createIndexedDBStorage(options) {
       return withRetry(async (db) => {
         let v = await db.get(storeName, name);
         v = v ?? null;
-        console.log("getItem:", db.objectStoreNames, storeName, name, v);
         return v;
       });
     },
     setItem: async (name, value) => {
       return withRetry(async (db) => {
-        console.log("setItem", name, value);
         await db.put(storeName, value, name);
       });
     },
     removeItem: async (name) => {
       return withRetry(async (db) => {
-        console.log("removeItem", name);
         await db.delete(storeName, name);
       });
     }
@@ -105,7 +582,14 @@ var DEFAULT_SYNC_INTERVAL_MILLIS = 5e3;
 var DEFAULT_LOGGER = console;
 var DEFAULT_MIN_LOG_LEVEL = "debug";
 var DEFAULT_MISSING_REMOTE_RECORD_ON_UPDATE_STRATEGY = "ignore";
-var SYNC_FIELDS = ["id", "_localId", "updated_at", "deleted"];
+function createWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
+  const store = (0, import_zustand.create)(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
+  return new Promise((resolve) => {
+    store.persist.onFinishHydration((_state) => {
+      resolve(store);
+    });
+  });
+}
 function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
   const syncInterval = syncOptions.syncInterval ?? DEFAULT_SYNC_INTERVAL_MILLIS;
   const missingStrategy = syncOptions.missingRemoteRecordDuringUpdateStrategy ?? DEFAULT_MISSING_REMOTE_RECORD_ON_UPDATE_STRATEGY;
@@ -115,14 +599,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
   const wrappedPersistOptions = {
     ...persistOptions,
     onRehydrateStorage: () => {
-      logger.debug("[persistWithSync] Rehydration started");
+      logger.debug("[Zync] Rehydration started");
       return (state, error) => {
         if (error) {
-          logger.error("[persistWithSync] Rehydration failed", error);
+          logger.error("[Zync] Rehydration failed", error);
         } else {
           baseOnRehydrate?.(state, error);
-          state.syncState.status = "idle";
-          logger.debug("[persistWithSync] Rehydration complete");
+          logger.debug("[Zync] Rehydration complete", state);
         }
       };
     },
@@ -137,24 +620,18 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           lastPulled: syncState.lastPulled
         }
       };
+    },
+    merge: (persisted, current) => {
+      const state = { ...current, ...persisted };
+      return {
+        ...state,
+        syncState: {
+          ...state.syncState,
+          status: "idle"
+          // this confirms 'hydrating' is done
+        }
+      };
     }
-    // merge: (persisted: any, current: any) => {
-    //     // Add unpersistable fields back e.g. functions or memory-only fields
-    //     const p = persisted || {};
-    //     const c = current || {};
-    //     return {
-    //         ...c,
-    //         ...p,
-    //         syncState: {
-    //             ...c.syncState,
-    //             ...p.syncState,
-    //             status: 'idle',
-    //             //firstLoadDone: p.syncState?.firstLoadDone ?? c.syncState.firstLoadDone ?? false,
-    //             //pendingChanges: p.syncState?.pendingChanges ?? c.syncState.pendingChanges ?? [],
-    //             //lastPulled: p.syncState?.lastPulled ?? c.syncState.lastPulled ?? {},
-    //         },
-    //     };
-    // },
   };
   const creator = (set, get, storeApi) => {
     let syncIntervalId;
@@ -174,7 +651,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           await pull(set, get, stateKey, api, logger);
         } catch (err) {
           syncError = syncError ?? err;
-          logger.error(`[persistWithSync] Pull error for stateKey: ${stateKey}`, err);
+          logger.error(`[Zync] Pull error for stateKey: ${stateKey}`, err);
         }
       }
       const snapshot = [...get().syncState.pendingChanges || []];
@@ -195,7 +672,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           );
         } catch (err) {
           syncError = syncError ?? err;
-          logger.error(`[persistWithSync] Push error for change: ${change}`, err);
+          logger.error(`[Zync] Push error for change: ${change}`, err);
         }
       }
       set((state2) => ({
@@ -205,41 +682,101 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           error: syncError
         }
       }));
+      if (get().syncState.pendingChanges.length > 0 && !syncError) {
+        await syncOnce();
+      }
     }
-    function queueToSync(action, stateKey, ...localIds) {
-      set((state) => {
-        const queue = state.syncState.pendingChanges || [];
-        for (const localId of localIds) {
-          const item = state[stateKey].find((i) => i._localId === localId);
-          if (!item) {
-            logger.error("[persistWithSync] queueToSync:no-local-item", {
-              stateKey,
-              localId
+    async function startFirstLoad() {
+      let syncError;
+      for (const stateKey of Object.keys(syncApi)) {
+        try {
+          logger.info(`[Zync] firstLoad:start for stateKey: ${stateKey}`);
+          const api = findApi(stateKey, syncApi);
+          let lastId;
+          while (true) {
+            const batch = await api.firstLoad(lastId);
+            if (!batch?.length) break;
+            set((state) => {
+              const local = state[stateKey] || [];
+              const localById = new Map(local.filter((l) => l.id).map((l) => [l.id, l]));
+              let newest = new Date(state.syncState.lastPulled[stateKey] || 0);
+              const next = [...local];
+              for (const remote of batch) {
+                const remoteUpdated = new Date(remote.updated_at || 0);
+                if (remoteUpdated > newest) newest = remoteUpdated;
+                if (remote.deleted) continue;
+                const localItem = remote.id ? localById.get(remote.id) : void 0;
+                if (localItem) {
+                  const merged = {
+                    ...localItem,
+                    ...remote,
+                    _localId: localItem._localId
+                  };
+                  const idx = next.findIndex((i) => i._localId === localItem._localId);
+                  if (idx >= 0) next[idx] = merged;
+                } else {
+                  next.push({
+                    ...remote,
+                    _localId: nextLocalId()
+                  });
+                }
+              }
+              return {
+                [stateKey]: next,
+                syncState: {
+                  ...state.syncState || {},
+                  lastPulled: {
+                    ...state.syncState.lastPulled || {},
+                    [stateKey]: newest.toISOString()
+                  }
+                }
+              };
             });
-            continue;
+            lastId = batch[batch.length - 1].id;
           }
-          if (action === "remove" /* Remove */ && !item.id) {
-            logger.warn("[persistWithSync] queueToSync:remove-no-id", {
+          logger.info(`[Zync] firstLoad:done for stateKey: ${stateKey}`);
+        } catch (err) {
+          syncError = syncError ?? err;
+          logger.error(`[Zync] First load pull error for stateKey: ${stateKey}`, err);
+        }
+      }
+      set((state) => ({
+        syncState: {
+          ...state.syncState || {},
+          firstLoadDone: true,
+          error: syncError
+        }
+      }));
+    }
+    function queueToSync(action, stateKey, ...localIds) {
+      set((state) => {
+        const pendingChanges = state.syncState.pendingChanges || [];
+        for (const localId of localIds) {
+          const item = state[stateKey].find((i) => i._localId === localId);
+          if (!item) {
+            logger.error("[Zync] queueToSync:no-local-item", {
               stateKey,
               localId
             });
             continue;
           }
-          const queueItem = queue.find((p) => p.localId === localId && p.stateKey === stateKey);
+          const queueItem = pendingChanges.find((p) => p.localId === localId && p.stateKey === stateKey);
           if (queueItem) {
             queueItem.version += 1;
             if (queueItem.action === "createOrUpdate" /* CreateOrUpdate */ && action === "remove" /* Remove */ && item.id) {
               queueItem.action = "remove" /* Remove */;
               queueItem.id = item.id;
             }
+            logger.debug(`[Zync] queueToSync:adjusted ${queueItem.version} ${action} ${item.id} ${stateKey} ${localId}`);
           } else {
-            queue.push({ action, stateKey, localId, id: item.id, version: 1 });
+            pendingChanges.push({ action, stateKey, localId, id: item.id, version: 1 });
+            logger.debug(`[Zync] queueToSync:added ${action} ${item.id} ${stateKey} ${localId}`);
           }
         }
         return {
           syncState: {
             ...state.syncState || {},
-            pendingChanges: queue
+            pendingChanges
           }
         };
       });
@@ -280,75 +817,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
     }
     function onVisibilityChange() {
       if (document.visibilityState === "visible") {
-        logger.debug("[persistWithSync] Sync started now app is in foreground");
+        logger.debug("[Zync] Sync started now app is in foreground");
         enableSyncTimer(true);
       } else {
-        logger.debug("[persistWithSync] Sync paused now app is in background");
+        logger.debug("[Zync] Sync paused now app is in background");
         enableSyncTimer(false);
       }
     }
-    async function startFirstLoad() {
-      let syncError;
-      for (const stateKey of Object.keys(syncApi)) {
-        try {
-          logger.info(`[persistWithSync] firstLoad:start for stateKey: ${stateKey}`);
-          const api = findApi(stateKey, syncApi);
-          let lastId;
-          while (true) {
-            const batch = await api.firstLoad(lastId);
-            if (!batch?.length) break;
-            set((state) => {
-              const local = state[stateKey] || [];
-              const localById = new Map(local.filter((l) => l.id).map((l) => [l.id, l]));
-              let newest = new Date(state.syncState.lastPulled[stateKey] || 0);
-              const next = [...local];
-              for (const remote of batch) {
-                const remoteUpdated = new Date(remote.updated_at || 0);
-                if (remoteUpdated > newest) newest = remoteUpdated;
-                if (remote.deleted) continue;
-                const localItem = remote.id ? localById.get(remote.id) : void 0;
-                if (localItem) {
-                  const merged = {
-                    ...localItem,
-                    ...remote,
-                    _localId: localItem._localId
-                  };
-                  const idx = next.findIndex((i) => i._localId === localItem._localId);
-                  if (idx >= 0) next[idx] = merged;
-                } else {
-                  next.push({
-                    ...remote,
-                    _localId: nextLocalId()
-                  });
-                }
-              }
-              return {
-                [stateKey]: next,
-                syncState: {
-                  ...state.syncState || {},
-                  lastPulled: {
-                    ...state.syncState.lastPulled || {},
-                    [stateKey]: newest.toISOString()
-                  }
-                }
-              };
-            });
-            lastId = batch[batch.length - 1].id;
-          }
-          logger.info(`[persistWithSync] firstLoad:done for stateKey: ${stateKey}`);
-        } catch (err) {
-          syncError = syncError ?? err;
-          logger.error(`[persistWithSync] First load pull error for stateKey: ${stateKey}`, err);
-        }
-      }
-      set((state) => ({
-        syncState: {
-          ...state.syncState || {},
-          firstLoadDone: true,
-          error: syncError
-        }
-      }));
-    }
     storeApi.sync = {
       enable,
       startFirstLoad
@@ -369,220 +844,11 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
   };
   return (0, import_middleware.persist)(creator, wrappedPersistOptions);
 }
-function createStoreWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
-  return (0, import_zustand.create)(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
-}
-function orderFor(a) {
-  switch (a) {
-    case "createOrUpdate" /* CreateOrUpdate */:
-      return 1;
-    case "remove" /* Remove */:
-      return 2;
-  }
-}
-async function pull(set, get, stateKey, api, logger) {
-  const lastPulled = get().syncState.lastPulled || {};
-  const lastPulledAt = new Date(lastPulled[stateKey] || /* @__PURE__ */ new Date(0));
-  logger.debug(`[persistWithSync] pull:start stateKey=${stateKey} since=${lastPulledAt.toISOString()}`);
-  const serverData = await api.list(lastPulledAt);
-  if (!serverData?.length) return;
-  let newest = lastPulledAt;
-  set((state) => {
-    const pendingChanges = state.syncState.pendingChanges || [];
-    const localItems = state[stateKey] || [];
-    let nextItems = [...localItems];
-    const localById = new Map(localItems.filter((l) => l.id).map((l) => [l.id, l]));
-    const pendingRemovalIds = /* @__PURE__ */ new Set();
-    for (const change of pendingChanges) {
-      if (change.stateKey === stateKey && change.action === "remove" /* Remove */) {
-        const item = localItems.find((i) => i._localId === change.localId);
-        if (item && item.id) pendingRemovalIds.add(item.id);
-      }
-    }
-    for (const remote of serverData) {
-      const remoteUpdated = new Date(remote.updated_at);
-      if (remoteUpdated > newest) newest = remoteUpdated;
-      const localItem = localById.get(remote.id);
-      if (pendingRemovalIds.has(remote.id)) {
-        logger.debug(`[persistWithSync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
-        continue;
-      }
-      if (remote.deleted) {
-        if (localItem) {
-          nextItems = nextItems.filter((i) => i.id !== remote.id);
-          logger.debug(`[persistWithSync] pull:remove stateKey=${stateKey} id=${remote.id}`);
-        }
-        continue;
-      }
-      const pending = localItem && pendingChanges.some((p) => p.stateKey === stateKey && p.localId === localItem._localId);
-      if (localItem && !pending) {
-        const merged = {
-          ...localItem,
-          ...remote,
-          _localId: localItem._localId
-        };
-        nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
-        logger.debug(`[persistWithSync] pull:merge stateKey=${stateKey} id=${remote.id}`);
-      } else if (!localItem) {
-        nextItems = [...nextItems, { ...remote, _localId: nextLocalId() }];
-        logger.debug(`[persistWithSync] pull:add stateKey=${stateKey} id=${remote.id}`);
-      }
-    }
-    return {
-      [stateKey]: nextItems,
-      syncState: {
-        ...state.syncState || {},
-        lastPulled: {
-          ...state.syncState.lastPulled || {},
-          [stateKey]: newest.toISOString()
-        }
-      }
-    };
-  });
-}
-async function pushOne(set, get, change, api, logger, queueToSync, missingStrategy, onMissingRemoteRecordDuringUpdate, onAfterRemoteAdd) {
-  logger.debug(`[persistWithSync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
-  const { action, stateKey, localId, id, version } = change;
-  switch (action) {
-    case "remove" /* Remove */:
-      await api.remove(id);
-      logger.debug(`[persistWithSync] push:remove:success ${stateKey} ${localId} ${id}`);
-      removeFromPendingChanges(set, localId, stateKey);
-      break;
-    case "createOrUpdate" /* CreateOrUpdate */:
-      const state = get();
-      const items = state[stateKey] || [];
-      const item = items.find((i) => i._localId === localId);
-      if (!item) {
-        logger.warn(`[persistWithSync] push:${action}:no-local-item`, {
-          stateKey,
-          localId
-        });
-        removeFromPendingChanges(set, localId, stateKey);
-        return;
-      }
-      let omittedItem = omitSyncFields(item);
-      if (item.id) {
-        const changed = await api.update(item.id, omittedItem);
-        if (changed) {
-          logger.debug("[persistWithSync] push:update:success", {
-            stateKey,
-            localId,
-            id: item.id
-          });
-          if (samePendingVersion(get, stateKey, localId, version)) {
-            removeFromPendingChanges(set, localId, stateKey);
-          }
-          return;
-        } else {
-          logger.warn("[persistWithSync] push:update:missingRemote", {
-            stateKey,
-            localId,
-            id: item.id
-          });
-          switch (missingStrategy) {
-            case "deleteLocalRecord":
-              set((s) => ({
-                [stateKey]: (s[stateKey] || []).filter((i) => i._localId !== localId)
-              }));
-              break;
-            case "insertNewRemoteRecord": {
-              omittedItem._localId = nextLocalId();
-              omittedItem.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-              set((s) => ({
-                [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? omittedItem : i)
-              }));
-              queueToSync("createOrUpdate" /* CreateOrUpdate */, stateKey, omittedItem._localId);
-              break;
-            }
-          }
-          removeFromPendingChanges(set, localId, stateKey);
-          onMissingRemoteRecordDuringUpdate?.(missingStrategy, omittedItem, omittedItem._localId);
-        }
-        return;
-      }
-      const result = await api.add(omittedItem);
-      if (result) {
-        logger.debug("[persistWithSync] push:create:success", {
-          stateKey,
-          localId,
-          id: result.id
-        });
-        set((s) => ({
-          [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? { ...i, ...result } : i)
-        }));
-        if (samePendingVersion(get, stateKey, localId, version)) {
-          removeFromPendingChanges(set, localId, stateKey);
-        }
-        onAfterRemoteAdd?.(set, get, queueToSync, stateKey, {
-          ...item,
-          ...result
-        });
-      } else {
-        logger.warn("[persistWithSync] push:create:no-result", {
-          stateKey,
-          localId
-        });
-        if (samePendingVersion(get, stateKey, localId, version)) {
-          removeFromPendingChanges(set, localId, stateKey);
-        }
-      }
-      break;
-  }
-}
-function samePendingVersion(get, stateKey, localId, version) {
-  const q = get().syncState.pendingChanges || [];
-  const curChange = q.find((p) => p.localId === localId && p.stateKey === stateKey);
-  return curChange?.version === version;
-}
-function removeFromPendingChanges(set, localId, stateKey) {
-  set((s) => {
-    const queue = (s.syncState.pendingChanges || []).filter((p) => !(p.localId === localId && p.stateKey === stateKey));
-    return {
-      syncState: {
-        ...s.syncState || {},
-        pendingChanges: queue
-      }
-    };
-  });
-}
-function omitSyncFields(item) {
-  const result = { ...item };
-  for (const k of SYNC_FIELDS) delete result[k];
-  return result;
-}
-function nextLocalId() {
-  return crypto.randomUUID();
-}
-function newLogger(logger, min) {
-  const order = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 40,
-    none: 100
-  };
-  const threshold = order[min];
-  const enabled = (lvl) => order[lvl] >= threshold;
-  return {
-    debug: (...a) => enabled("debug") && logger.debug?.(...a),
-    info: (...a) => enabled("info") && logger.info?.(...a),
-    warn: (...a) => enabled("warn") && logger.warn?.(...a),
-    error: (...a) => enabled("error") && logger.error?.(...a)
-  };
-}
-function findApi(stateKey, syncApi) {
-  const api = syncApi[stateKey];
-  if (!api || !api.add || !api.update || !api.remove || !api.list || !api.firstLoad) {
-    throw new Error(`Missing API function(s) for state key: ${stateKey}.`);
-  }
-  return api;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SyncAction,
   createIndexedDBStorage,
-  createStoreWithSync,
+  createWithSync,
   nextLocalId,
   persistWithSync
 });