tinybase 5.0.0-beta.3 → 5.0.0-beta.5

package/lib/debug/mergeable-store.js

@@ -24,9 +24,9 @@ const VALUE_IDS = VALUE + IDS;
 const id = (key) => EMPTY_STRING + key;
 const strStartsWith = (str, prefix) => str.startsWith(prefix);
 const strEndsWith = (str, suffix) => str.endsWith(suffix);
-const strSplit = (str, separator = '', limit) => str.split(separator, limit);
-const strCharCodeAt = (str, position = 0) => str.charCodeAt(position);
+const strCharCodeAt = (str, position) => str.charCodeAt(position);
 
+const mathMax = Math.max;
 const isFiniteNumber = isFinite;
 const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isUndefined = (thing) => thing == void 0;
@@ -79,6 +79,12 @@ const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+const objEnsure = (obj, id, getDefaultValue) => {
+  if (!objHas(obj, id)) {
+    obj[id] = getDefaultValue();
+  }
+  return obj[id];
+};
 
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
@@ -102,9 +108,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
@@ -162,34 +170,36 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-const stampNew = () => [EMPTY_STRING, void 0];
-const stampNewMap = () => [EMPTY_STRING, mapNew()];
-const mapStamp = ([stamp, value], mapper) => [stamp, mapper(value, stamp)];
-const mapStampMapToObj = (stampedMap, mapper) =>
-  mapStamp(stampedMap, (map) => mapToObj(map, mapper));
-const mergeStamps = (newThingStamps, thingStamps, changes, merge) =>
-  objForEach(newThingStamps, (newThingStamp, thingId) =>
-    mergeStamp(
-      newThingStamp,
-      mapEnsure(thingStamps, thingId, stampNewMap),
-      (changes[thingId] = objNew()),
-      merge,
-    ),
-  );
-const mergeStamp = ([newTime, newThing], thingStamp, changes, merge) => {
-  if (newTime > thingStamp[0]) {
-    thingStamp[0] = newTime;
+const textEncoder = new globalThis.TextEncoder();
+const getHash = (value) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(value), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+
+const cloneHashStamp = ([time, value, hash]) => [time, value, hash];
+const stampNew = (time, thing) => [time, thing];
+const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
+const updateHashStamp = (hashStamp, hash, time) => {
+  hashStamp[2] = hash >>> 0;
+  if (time > hashStamp[0]) {
+    hashStamp[0] = time;
   }
-  merge(newThing, thingStamp[1], changes);
 };
-const mergeLeafStamps = (newLeafStamps, leafStamps, changes) =>
-  objForEach(newLeafStamps, ([newTime, newLeaf], leafId) => {
-    const leafStamp = mapEnsure(leafStamps, leafId, stampNew);
-    if (newTime > leafStamp[0]) {
-      leafStamp[0] = newTime;
-      leafStamp[1] = changes[leafId] = newLeaf;
-    }
-  });
+const stampNewObj = (time) => stampNew(time, objNew());
+const hashStampNewMap = (time = EMPTY_STRING) => [time, mapNew(), 0];
+const hashStampNewThing = () => [EMPTY_STRING, void 0, 0];
+const hashStampMap = ([time, value, hash], mapper) => [
+  time,
+  mapper(value, time),
+  hash,
+];
+const hashStampMapToObj = (hashStamp, mapper = cloneHashStamp) =>
+  hashStampMap(hashStamp, (map) => mapToObj(map, mapper));
 
 const setNew = (entryOrEntries) =>
   new Set(
@@ -289,9 +299,10 @@ const pairNewMap = () => [mapNew(), mapNew()];
 const pairClone = (array) => [...array];
 const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
-const getCellOrValueType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+const getCellOrValueType = (cellOrValue) => {
+  const type = getTypeOf(cellOrValue);
+  return isTypeStringOrBoolean(type) ||
+    (type == NUMBER && isFiniteNumber(cellOrValue))
     ? type
     : void 0;
 };
@@ -332,12 +343,10 @@ const idsChanged = (changedIds, id2, addedOrRemoved) =>
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
-  let cellsTouched = false;
-  let valuesTouched = false;
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
-  let postTransactionListener;
+  let internalListeners = [];
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -1297,8 +1306,8 @@ const createStore = () => {
     ),
   ];
   const getTransactionLog = () => [
-    cellsTouched,
-    valuesTouched,
+    !collIsEmpty(changedCells),
+    !collIsEmpty(changedValues),
     mapToObj3(changedCells, pairClone, pairIsEqual),
     mapToObj3(invalidCells),
     mapToObj(changedValues, pairClone, pairIsEqual),
@@ -1312,15 +1321,13 @@ const createStore = () => {
     if (transactions > 0) {
       transactions--;
       if (transactions == 0) {
-        cellsTouched = !collIsEmpty(changedCells);
-        valuesTouched = !collIsEmpty(changedValues);
         transactions = 1;
         callInvalidCellListeners(1);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(1);
         }
         callInvalidValueListeners(1);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(1);
         }
         if (doRollback?.(store)) {
@@ -1331,25 +1338,26 @@ const createStore = () => {
               ),
             ),
           );
+          collClear(changedCells);
           collForEach(changedValues, ([oldValue], valueId) =>
             setOrDelValue(store, valueId, oldValue),
           );
-          cellsTouched = valuesTouched = false;
+          collClear(changedValues);
         }
         callListeners(finishTransactionListeners[0], void 0);
         transactions = -1;
         callInvalidCellListeners(0);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(0);
         }
         callInvalidValueListeners(0);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(0);
         }
-        postTransactionListener?.(store);
+        internalListeners[0]?.(store);
         callListeners(finishTransactionListeners[1], void 0);
+        internalListeners[1]?.(store);
         transactions = 0;
-        cellsTouched = valuesTouched = false;
         hadTables = hasTables();
         hadValues = hasValues();
         arrayForEach(
@@ -1474,9 +1482,8 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
-  const addPostTransactionListener = (listener) => {
-    postTransactionListener = listener;
-  };
+  const setInternalListeners = (preFinishTransaction, postFinishTransaction) =>
+    (internalListeners = [preFinishTransaction, postFinishTransaction]);
   const store = {
     getContent,
     getTables,
@@ -1554,7 +1561,7 @@ const createStore = () => {
     createStore,
     addListener,
     callListeners,
-    addPostTransactionListener,
+    setInternalListeners,
   };
   objToArray(
     {
@@ -1638,12 +1645,6 @@ const SHIFT12 = 2 ** 12;
 const SHIFT6 = 2 ** 6;
 const toB64 = (num) => String.fromCharCode(48 + (num & MASK6));
 const fromB64 = (str, pos) => strCharCodeAt(str, pos) - 48;
-const hash = (value) =>
-  arrayReduce(
-    strSplit(value),
-    (hash2, char) => ((hash2 << 5) + hash2) ^ strCharCodeAt(char),
-    5381,
-  ) >>> 0;
 const encodeHlc = (logicalTime42, counter24, clientHash30) =>
   toB64(logicalTime42 / SHIFT36) +
   toB64(logicalTime42 / SHIFT30) +
@@ -1681,23 +1682,23 @@ const decodeHlc = (hlc16) => [
 ];
 const getHlcFunctions = (uniqueId) => {
   let logicalTime = 0;
-  let counter = 0;
-  const uniqueIdHash = hash(uniqueId);
+  let lastCounter = -1;
+  const uniqueIdHash = getHash(uniqueId);
   const getHlc = () => {
     seenHlc();
-    return encodeHlc(logicalTime, ++counter, uniqueIdHash);
+    return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
   };
   const seenHlc = (hlc) => {
     const previousLogicalTime = logicalTime;
     const [remoteLogicalTime, remoteCounter] = isUndefined(hlc)
       ? [0, 0]
       : decodeHlc(hlc);
-    logicalTime = Math.max(previousLogicalTime, remoteLogicalTime, Date.now());
-    counter =
+    logicalTime = mathMax(previousLogicalTime, remoteLogicalTime, Date.now());
+    lastCounter =
       logicalTime == previousLogicalTime
         ? logicalTime == remoteLogicalTime
-          ? Math.max(counter, remoteCounter)
-          : counter
+          ? mathMax(lastCounter, remoteCounter)
+          : lastCounter
         : logicalTime == remoteLogicalTime
           ? remoteCounter
           : -1;
@@ -1723,10 +1724,16 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
-const newContentStamp = () => [EMPTY_STRING, [stampNewMap(), stampNewMap()]];
+const newContentHsm = (time = EMPTY_STRING) => [
+  time,
+  [hashStampNewMap(time), hashStampNewMap(time)],
+  0,
+];
 const createMergeableStore = (id) => {
   let listening = 1;
-  let contentStamp = newContentStamp();
+  let contentHsm = newContentHsm();
+  let transactionTime;
+  let transactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
   const store = createStore();
   const disableListening = (actions) => {
@@ -1735,105 +1742,206 @@ const createMergeableStore = (id) => {
     actions();
     listening = wasListening;
   };
-  const postTransactionListener = () => {
-    if (listening) {
-      const stamp = getHlc();
-      const [cellsTouched, valuesTouched, changedCells, , changedValues] =
-        store.getTransactionLog();
-      const [tablesStamp, valuesStamp] = contentStamp[1];
-      contentStamp[0] = stamp;
-      if (cellsTouched) {
-        tablesStamp[0] = stamp;
-        objToArray(changedCells, (changedTable, tableId) => {
-          const tableStamp = mapEnsure(tablesStamp[1], tableId, stampNew);
-          const rowsStamp = (tableStamp[1] ??= mapNew());
-          tableStamp[0] = stamp;
-          objToArray(changedTable, (changedRow, rowId) => {
-            const rowStamp = mapEnsure(rowsStamp, rowId, stampNew);
-            const cellsStamp = (rowStamp[1] ??= mapNew());
-            rowStamp[0] = stamp;
-            objToArray(changedRow, ([, newCell], cellId) =>
-              mapSet(cellsStamp, cellId, [stamp, newCell]),
+  const mergeContentOrChanges = (contentOrChanges, hasHashes = 0) => {
+    const tablesChanges = {};
+    const valuesChanges = {};
+    const [
+      contentOrChangesTime,
+      [[tablesTime, tablesObj, incomingTablesHash], values],
+      incomingContentOrChangesHash,
+    ] = contentOrChanges;
+    const [, [tablesHsm, valuesHsm]] = contentHsm;
+    const [oldTablesTime, tableHsms, oldTablesHash] = tablesHsm;
+    if (tablesTime) {
+      let tablesHash = hasHashes
+        ? incomingTablesHash
+        : oldTablesHash ^
+          (tablesTime > oldTablesTime
+            ? (oldTablesTime ? getHash(oldTablesTime) : 0) ^ getHash(tablesTime)
+            : 0);
+      objForEach(
+        tablesObj,
+        ([tableTime, rowsObj, incomingTableHash], tableId) => {
+          const tableHsm = mapEnsure(tableHsms, tableId, hashStampNewMap);
+          const [oldTableTime, rowHsms, oldTableHash] = tableHsm;
+          let tableHash = hasHashes
+            ? incomingTableHash
+            : oldTableHash ^
+              (tableTime > oldTableTime
+                ? (oldTableTime ? getHash(oldTableTime) : 0) ^
+                  getHash(tableTime)
+                : 0);
+          objForEach(rowsObj, (row, rowId) => {
+            const [oldRowHash, rowHash] = mergeCellsOrValues(
+              row,
+              mapEnsure(rowHsms, rowId, hashStampNewMap),
+              objEnsure(
+                objEnsure(tablesChanges, tableId, objNew),
+                rowId,
+                objNew,
+              ),
+              hasHashes,
             );
+            tableHash ^= hasHashes
+              ? 0
+              : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
+                hashIdAndHash(rowId, rowHash);
           });
-        });
-      }
-      if (valuesTouched) {
-        valuesStamp[0] = stamp;
-        objToArray(changedValues, ([, newValue], valueId) => {
-          mapSet(valuesStamp[1], valueId, [stamp, newValue]);
-        });
-      }
+          updateHashStamp(tableHsm, tableHash, tableTime);
+          tablesHash ^= hasHashes
+            ? 0
+            : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
+              hashIdAndHash(tableId, tableHsm[2]);
+        },
+      );
+      updateHashStamp(tablesHsm, tablesHash, tablesTime);
     }
+    mergeCellsOrValues(values, valuesHsm, valuesChanges, hasHashes);
+    updateHashStamp(
+      contentHsm,
+      hasHashes ? incomingContentOrChangesHash : tablesHsm[2] ^ valuesHsm[2],
+      contentOrChangesTime,
+    );
+    return [tablesChanges, valuesChanges];
   };
-  const merge = (mergeableStore2) => {
-    const mergeableContent = mergeableStore.getMergeableContent();
-    const mergeableContent2 = mergeableStore2.getMergeableContent();
-    mergeableStore2.applyMergeableChanges(mergeableContent);
-    return applyMergeableChanges(mergeableContent2);
+  const mergeCellsOrValues = (things, thingsHsm, thingsChanges, hasHashes) => {
+    const [thingsTime, thingsObj, incomingThingsHash] = things;
+    const [oldThingsTime, thingHsms, oldThingsHash] = thingsHsm;
+    if (thingsTime) {
+      let thingsHash = hasHashes
+        ? incomingThingsHash
+        : oldThingsHash ^
+          (thingsTime > oldThingsTime
+            ? (oldThingsTime ? getHash(oldThingsTime) : 0) ^ getHash(thingsTime)
+            : 0);
+      objForEach(
+        thingsObj,
+        ([thingTime, thing, incomingThingHash], thingId) => {
+          const thingHsm = mapEnsure(thingHsms, thingId, hashStampNewThing);
+          const [oldThingTime, , oldThingHash] = thingHsm;
+          if (thingTime > oldThingTime) {
+            updateHashStamp(
+              thingHsm,
+              hasHashes
+                ? incomingThingHash
+                : getHash(jsonString(thing ?? null) + ':' + thingTime),
+              thingTime,
+            );
+            thingHsm[1] = thing;
+            thingsChanges[thingId] = thing;
+            thingsHash ^= hasHashes
+              ? 0
+              : hashIdAndHash(thingId, oldThingHash) ^
+                hashIdAndHash(thingId, thingHsm[2]);
+          }
+        },
+      );
+      updateHashStamp(thingsHsm, thingsHash, thingsTime);
+    }
+    return [oldThingsHash, thingsHsm[2]];
+  };
+  const preFinishTransaction = () => {
+    if (listening) {
+      transactionMergeableChanges = getTransactionMergeableChanges();
+      mergeContentOrChanges(transactionMergeableChanges);
+    }
   };
+  const postFinishTransaction = () =>
+    (transactionTime = transactionMergeableChanges = void 0);
   const getMergeableContent = () =>
-    mapStamp(contentStamp, ([tablesStamp, valuesStamp]) => [
-      mapStampMapToObj(tablesStamp, (rowsStamp) =>
-        mapStampMapToObj(rowsStamp, (cellsStamp) =>
-          mapStampMapToObj(cellsStamp, pairClone),
-        ),
+    hashStampMap(contentHsm, ([tables, values]) => [
+      hashStampMapToObj(tables, (table) =>
+        hashStampMapToObj(table, (row) => hashStampMapToObj(row)),
       ),
-      mapStampMapToObj(valuesStamp, pairClone),
+      hashStampMapToObj(values),
     ]);
   const setMergeableContent = (mergeableContent) => {
     disableListening(() =>
       store.transaction(() => {
         store.delTables().delValues();
-        contentStamp = newContentStamp();
+        contentHsm = newContentHsm();
       }),
     );
-    applyMergeableChanges(mergeableContent);
+    seenHlc(mergeableContent[0]);
+    disableListening(() =>
+      store.applyChanges(mergeContentOrChanges(mergeableContent, 1)),
+    );
     return mergeableStore;
   };
-  const applyMergeableChanges = (newContentStamp2) => {
-    const changes = [{}, {}];
-    seenHlc(newContentStamp2[0]);
-    mergeStamp(
-      newContentStamp2,
-      contentStamp,
-      changes,
-      (
-        [newTablesStamp, newValuesStamp],
-        [tablesStamp, valuesStamp],
-        [tablesChanges, valuesChanges],
-      ) => {
-        mergeStamp(
-          newTablesStamp,
-          tablesStamp,
-          tablesChanges,
-          (newTableStamps, tableStamps, tableChanges) =>
-            mergeStamps(
-              newTableStamps,
-              tableStamps,
-              tableChanges,
-              (newRowStamps, rowStamps, rowChanges) =>
-                mergeStamps(
-                  newRowStamps,
-                  rowStamps,
-                  rowChanges,
-                  mergeLeafStamps,
-                ),
-            ),
-        );
-        mergeStamp(newValuesStamp, valuesStamp, valuesChanges, mergeLeafStamps);
-      },
+  const getTransactionMergeableChanges = () => {
+    if (isUndefined(transactionMergeableChanges)) {
+      const [, , changedCells, , changedValues] = store.getTransactionLog();
+      const time =
+        !objIsEmpty(changedCells) || !objIsEmpty(changedValues)
+          ? transactionTime ?? (transactionTime = getHlc())
+          : EMPTY_STRING;
+      const mergeableChanges = stampNew(time, [
+        stampNewObj(objIsEmpty(changedCells) ? EMPTY_STRING : time),
+        stampNewObj(objIsEmpty(changedValues) ? EMPTY_STRING : time),
+      ]);
+      const [[, tablesObj], [, valuesObj]] = mergeableChanges[1];
+      objToArray(changedCells, (changedTable, tableId) => {
+        const [, rowsObj] = (tablesObj[tableId] = stampNewObj(time));
+        objToArray(changedTable, (changedRow, rowId) => {
+          const [, cellsObj] = (rowsObj[rowId] = stampNewObj(time));
+          objToArray(
+            changedRow,
+            ([, newCell], cellId) =>
+              (cellsObj[cellId] = stampNew(time, newCell)),
+          );
+        });
+      });
+      objToArray(
+        changedValues,
+        ([, newValue], valueId) =>
+          (valuesObj[valueId] = stampNew(time, newValue)),
+      );
+      return mergeableChanges;
+    }
+    return transactionMergeableChanges;
+  };
+  const applyMergeableChanges = (mergeableChanges) => {
+    seenHlc(mergeableChanges[0]);
+    disableListening(() =>
+      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
     );
-    disableListening(() => store.applyChanges(changes));
     return mergeableStore;
   };
+  const merge = (mergeableStore2) => {
+    const mergeableChanges = getMergeableContent();
+    const mergeableChanges2 = mergeableStore2.getMergeableContent();
+    mergeableStore2.applyMergeableChanges(mergeableChanges);
+    return applyMergeableChanges(mergeableChanges2);
+  };
+  const getContentHash = () => contentHsm[2];
+  const getTablesHash = () => contentHsm[1][0][2];
+  const getTableHash = (tableId) =>
+    mapGet(contentHsm[1][0][1], tableId)?.[2] ?? 0;
+  const getRowHash = (tableId, rowId) =>
+    mapGet(mapGet(contentHsm[1][0][1], tableId)?.[1], rowId)?.[2] ?? 0;
+  const getCellHash = (tableId, rowId, cellId) =>
+    mapGet(
+      mapGet(mapGet(contentHsm[1][0][1], tableId)?.[1], rowId)?.[1],
+      cellId,
+    )?.[2] ?? 0;
+  const getValuesHash = () => contentHsm[1][1][2];
+  const getValueHash = (valueId) =>
+    mapGet(contentHsm[1][1][1], valueId)?.[2] ?? 0;
   const mergeableStore = {
     getMergeableContent,
     setMergeableContent,
+    getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
+    getContentHash,
+    getTablesHash,
+    getTableHash,
+    getRowHash,
+    getCellHash,
+    getValuesHash,
+    getValueHash,
   };
-  store.addPostTransactionListener(postTransactionListener);
+  store.setInternalListeners(preFinishTransaction, postFinishTransaction);
   objToArray(
     store,
     (method, name) =>

package/lib/debug/metrics.js

@@ -52,9 +52,11 @@ const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-automerge.js

@@ -52,15 +52,34 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
+const isMergeable = (contentOrChanges) => isString(contentOrChanges?.[0]);
+const getStoreFunctions = (supportsMergeableStore, store) =>
+  !supportsMergeableStore || isUndefined(store.getMergeableContent)
+    ? [
+        0,
+        store.getContent,
+        store.getTransactionChanges,
+        ([changedTables, changedValues]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ]
+    : [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([, [[, changedTables], [, changedValues]]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ];
 const createCustomPersister = (
   store,
   getPersisted,
@@ -81,10 +100,8 @@ const createCustomPersister = (
   let listeningHandle;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
-  const getContent =
-    (supportsMergeableStore ? store.getMergeableContent : null) ??
-    store.getContent;
-  const getChanges = store.getTransactionChanges;
+  const [isMergeableStore, getContent, getChanges, hasChanges] =
+    getStoreFunctions(supportsMergeableStore, store);
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -121,8 +138,8 @@ const createCustomPersister = (
       await loadLock(async () => {
         try {
           const content = await getPersisted();
-          (supportsMergeableStore && isString(content[0])
-            ? store.applyMergeableChanges
+          (isMergeableStore && isMergeable(content)
+            ? store.setMergeableContent
             : store.setContent)(content);
         } catch {
           store.setContent([initialTables, initialValues]);
@@ -136,11 +153,18 @@ const createCustomPersister = (
         async (getContent2, getChanges2) => {
           if (getChanges2) {
             const changes = getChanges2();
-            await loadLock(async () => store.applyChanges(changes));
+            await loadLock(async () =>
+              (isMergeableStore && isMergeable(changes)
+                ? store.applyMergeableChanges
+                : store.applyChanges)(changes),
+            );
           } else {
             await loadLock(async () => {
               try {
-                store.setContent(getContent2?.() ?? (await getPersisted()));
+                const content = getContent2?.() ?? (await getPersisted());
+                (isMergeableStore && isMergeable(content)
+                  ? store.setMergeableContent
+                  : store.setContent)(content);
               } catch (error) {
                 onIgnoredError?.(error);
               }
@@ -180,9 +204,9 @@ const createCustomPersister = (
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
       listenerId = store.addDidFinishTransactionListener(() => {
-        const [tableChanges, valueChanges] = getChanges();
-        if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-          persister.save(() => [tableChanges, valueChanges]);
+        const changes = getChanges();
+        if (hasChanges(changes)) {
+          persister.save(() => changes);
         }
       });
       return persister;