tinybase 5.0.0-beta.4 → 5.0.0-beta.6

package/lib/debug/mergeable-store.js

@@ -24,8 +24,7 @@ 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;
@@ -34,6 +33,7 @@ const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
 const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
 const isArray = (thing) => Array.isArray(thing);
 const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
@@ -55,9 +55,7 @@ const arrayShift = (array) => array.shift();
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
-const objIds = object.keys;
 const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -68,6 +66,8 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
+const objIds = object.keys;
+const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
 const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
@@ -78,8 +78,33 @@ const objForEach = (obj, cb) =>
   arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
 const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objMap = (obj, cb) =>
+  objNew(objToArray(obj, (value, id) => [id, 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 objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
+  if (
+    isUndefined(obj) ||
+    !isObject(obj) ||
+    (!emptyIsValid && objIsEmpty(obj)) ||
+    objFrozen(obj)
+  ) {
+    onInvalidObj?.();
+    return false;
+  }
+  objToArray(obj, (child, id) => {
+    if (!validateChild(child, id)) {
+      objDel(obj, id);
+    }
+  });
+  return emptyIsValid ? true : !objIsEmpty(obj);
+};
 
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
@@ -103,9 +128,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);
 };
@@ -114,24 +141,28 @@ const mapMatch = (map, obj, set, del = mapSet) => {
   mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
   return map;
 };
-const mapToObj = (map, mapValue, excludeValue) => {
+const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
   const obj = {};
-  collForEach(map, (value, id) => {
-    const mappedValue = mapValue ? mapValue(value, id) : value;
-    excludeValue?.(mappedValue, value) ? 0 : (obj[id] = mappedValue);
+  collForEach(map, (mapValue, id) => {
+    if (!excludeMapValue?.(mapValue, id)) {
+      const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
+      excludeObjValue?.(objValue) ? 0 : (obj[id] = objValue);
+    }
   });
   return obj;
 };
-const mapToObj2 = (map, mapValue, excludeValue) =>
+const mapToObj2 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
-const mapToObj3 = (map, mapValue, excludeValue) =>
+const mapToObj3 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj2(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
 const mapClone = (map, mapValue) => {
@@ -163,36 +194,40 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-const stampNew = (time = EMPTY_STRING, thing) => [time, thing];
-const stampNewMap = (time = EMPTY_STRING) => stampNew(time, mapNew());
-const stampNewObj = (time) => stampNew(time, objNew());
-const mapStamp = ([time, value], mapper) => [time, mapper(value, time)];
-const cloneStamp = ([time, value]) => [time, value];
-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 stampCloneWithHash = ([time, value, hash]) => [time, value, hash];
+const stampClone = ([time, value]) => [time, value];
+const getStampHash = (stamp) => stamp[2];
+const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
+const stampUpdate = (stamp, hash, time) => {
+  stamp[2] = hash >>> 0;
+  if (time > stamp[0]) {
+    stamp[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) => [time, objNew()];
+const stampNewMap = (time = EMPTY_STRING) => [time, mapNew(), 0];
+const stampMapToObjWithHash = (
+  [time, map, hash],
+  mapper = stampCloneWithHash,
+) => [time, mapToObj(map, mapper), hash];
+const stampValidate = (stamp, validateThing) =>
+  isArray(stamp) &&
+  size(stamp) == 3 &&
+  isString(stamp[0]) &&
+  validateThing(stamp[1]) &&
+  getTypeOf(stamp[2]) == NUMBER &&
+  isFiniteNumber(stamp[2]);
 
 const setNew = (entryOrEntries) =>
   new Set(
@@ -292,12 +327,15 @@ 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;
 };
+const isCellOrValueOrNull = (cellOrValue) =>
+  cellOrValue === null || !isUndefined(getCellOrValueType(cellOrValue));
 const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
   isUndefined(cell)
     ? store.delCell(tableId, rowId, cellId, true)
@@ -314,18 +352,6 @@ const jsonParse = JSON.parse;
 const defaultSorter = (sortKey1, sortKey2) =>
   (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
 
-const validate = (obj, validateChild, onInvalidObj) => {
-  if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
-    onInvalidObj?.();
-    return false;
-  }
-  objToArray(obj, (child, id2) => {
-    if (!validateChild(child, id2)) {
-      objDel(obj, id2);
-    }
-  });
-  return !objIsEmpty(obj);
-};
 const idsChanged = (changedIds, id2, addedOrRemoved) =>
   mapSet(
     changedIds,
@@ -385,13 +411,13 @@ const createStore = () => {
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
   const validateTablesSchema = (tableSchema) =>
-    validate(tableSchema, (tableSchema2) =>
-      validate(tableSchema2, validateCellOrValueSchema),
+    objValidate(tableSchema, (tableSchema2) =>
+      objValidate(tableSchema2, validateCellOrValueSchema),
     );
   const validateValuesSchema = (valuesSchema) =>
-    validate(valuesSchema, validateCellOrValueSchema);
+    objValidate(valuesSchema, validateCellOrValueSchema);
   const validateCellOrValueSchema = (schema) => {
-    if (!validate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
+    if (!objValidate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
       return false;
     }
     const type = schema[TYPE];
@@ -404,18 +430,18 @@ const createStore = () => {
     return true;
   };
   const validateTables = (tables) =>
-    validate(tables, validateTable, cellInvalid);
+    objValidate(tables, validateTable, cellInvalid);
   const validateTable = (table, tableId) =>
     (!hasTablesSchema ||
       collHas(tablesSchemaMap, tableId) ||
       cellInvalid(tableId)) &&
-    validate(
+    objValidate(
       table,
       (row, rowId) => validateRow(tableId, rowId, row),
       () => cellInvalid(tableId),
     );
   const validateRow = (tableId, rowId, row, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
       (cell, cellId) =>
         ifNotUndefined(
@@ -442,7 +468,7 @@ const createStore = () => {
         ? cellInvalid(tableId, rowId, cellId, cell)
         : cell;
   const validateValues = (values, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
       (value, valueId) =>
         ifNotUndefined(
@@ -1285,17 +1311,20 @@ const createStore = () => {
                   : mapToObj(
                       row,
                       ([, newCell]) => newCell,
-                      (_, changedCell) => pairIsEqual(changedCell),
+                      (changedCell) => pairIsEqual(changedCell),
                     ),
+              collIsEmpty,
               objIsEmpty,
             ),
+      collIsEmpty,
       objIsEmpty,
     ),
     mapToObj(
       changedValues,
       ([, newValue]) => newValue,
-      (_, changedValue) => pairIsEqual(changedValue),
+      (changedValue) => pairIsEqual(changedValue),
     ),
+    1,
   ];
   const getTransactionLog = () => [
     !collIsEmpty(changedCells),
@@ -1637,12 +1666,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,17 +1704,20 @@ const decodeHlc = (hlc16) => [
 const getHlcFunctions = (uniqueId) => {
   let logicalTime = 0;
   let lastCounter = -1;
-  const uniqueIdHash = hash(uniqueId);
+  const uniqueIdHash = getHash(uniqueId);
   const getHlc = () => {
     seenHlc();
     return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
   };
   const seenHlc = (hlc) => {
     const previousLogicalTime = logicalTime;
-    const [remoteLogicalTime, remoteCounter] = isUndefined(hlc)
-      ? [0, 0]
-      : decodeHlc(hlc);
-    logicalTime = mathMax(previousLogicalTime, remoteLogicalTime, Date.now());
+    const [remoteLogicalTime, remoteCounter] =
+      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeHlc(hlc);
+    logicalTime = mathMax(
+      previousLogicalTime,
+      remoteLogicalTime,
+      globalThis.HLC_TIME ?? Date.now(),
+    );
     lastCounter =
       logicalTime == previousLogicalTime
         ? logicalTime == remoteLogicalTime
@@ -1722,15 +1748,56 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
-const newContentStamp = (time = EMPTY_STRING) => [
+const newContentStampMap = (time = EMPTY_STRING) => [
   time,
   [stampNewMap(time), stampNewMap(time)],
+  0,
 ];
+const validateMergeableContent = (mergeableContent) =>
+  stampValidate(
+    mergeableContent,
+    (content) =>
+      isArray(content) &&
+      size(content) == 2 &&
+      stampValidate(content[0], (tableStamps) =>
+        objValidate(
+          tableStamps,
+          (tableStamp) =>
+            stampValidate(tableStamp, (rowStamps) =>
+              objValidate(
+                rowStamps,
+                (rowStamp) =>
+                  stampValidate(rowStamp, (cellStamps) =>
+                    objValidate(
+                      cellStamps,
+                      (cellStamp) =>
+                        stampValidate(cellStamp, isCellOrValueOrNull),
+                      void 0,
+                      1,
+                    ),
+                  ),
+                void 0,
+                1,
+              ),
+            ),
+          void 0,
+          1,
+        ),
+      ) &&
+      stampValidate(content[1], (values) =>
+        objValidate(
+          values,
+          (value) => stampValidate(value, isCellOrValueOrNull),
+          void 0,
+          1,
+        ),
+      ),
+  );
 const createMergeableStore = (id) => {
   let listening = 1;
-  let contentStamp = newContentStamp();
+  let contentStampMap = newContentStampMap();
   let transactionTime;
-  let finishTransactionMergeableChanges;
+  let transactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
   const store = createStore();
   const disableListening = (actions) => {
@@ -1738,137 +1805,294 @@ const createMergeableStore = (id) => {
     listening = 0;
     actions();
     listening = wasListening;
+    return mergeableStore;
   };
-  const preFinishTransaction = () => {
-    if (listening) {
-      finishTransactionMergeableChanges = getTransactionMergeableChanges();
-      const [time, [changedTablesStamp, changedValuesStamp]] =
-        finishTransactionMergeableChanges;
-      const cellsTouched = !objIsEmpty(changedTablesStamp[1]);
-      const valuesTouched = !objIsEmpty(changedValuesStamp[1]);
-      const [, [tablesStamp, valuesStamp]] = contentStamp;
-      if (cellsTouched || valuesTouched) {
-        contentStamp[0] = time;
-      }
-      if (cellsTouched) {
-        tablesStamp[0] = time;
-        objToArray(changedTablesStamp[1], ([, changedRowStamps], tableId) => {
-          const tableStamp = mapEnsure(tablesStamp[1], tableId, stampNewMap);
-          tableStamp[0] = time;
-          objToArray(changedRowStamps, ([, changedCellStamps], rowId) => {
-            const rowStamp = mapEnsure(tableStamp[1], rowId, stampNewMap);
-            rowStamp[0] = time;
-            objToArray(changedCellStamps, ([, newCell], cellId) =>
-              mapSet(rowStamp[1], cellId, stampNew(time, newCell)),
+  const mergeContentOrChanges = (contentOrChanges, hasHashes = 0) => {
+    const tablesChanges = {};
+    const valuesChanges = {};
+    const [
+      contentOrChangesTime,
+      [[tablesTime, tablesObj, incomingTablesHash], values],
+      incomingContentOrChangesHash,
+    ] = contentOrChanges;
+    const [, [tablesStampMap, valuesStampMap]] = contentStampMap;
+    const [oldTablesTime, tableStampMaps, oldTablesHash] = tablesStampMap;
+    if (tablesTime) {
+      let tablesHash = hasHashes
+        ? incomingTablesHash
+        : oldTablesHash ^
+          (tablesTime > oldTablesTime
+            ? (oldTablesTime ? getHash(oldTablesTime) : 0) ^ getHash(tablesTime)
+            : 0);
+      objForEach(
+        tablesObj,
+        ([tableTime, rowsObj, incomingTableHash], tableId) => {
+          const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
+          const [oldTableTime, rowStampMaps, oldTableHash] = tableStampMap;
+          let tableHash = hasHashes
+            ? incomingTableHash
+            : oldTableHash ^
+              (tableTime > oldTableTime
+                ? (oldTableTime ? getHash(oldTableTime) : 0) ^
+                  getHash(tableTime)
+                : 0);
+          objForEach(rowsObj, (row, rowId) => {
+            const [oldRowHash, rowHash] = mergeCellsOrValues(
+              row,
+              mapEnsure(rowStampMaps, rowId, stampNewMap),
+              objEnsure(
+                objEnsure(tablesChanges, tableId, objNew),
+                rowId,
+                objNew,
+              ),
+              hasHashes,
             );
+            tableHash ^= hasHashes
+              ? 0
+              : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
+                hashIdAndHash(rowId, rowHash);
           });
-        });
-      }
-      if (valuesTouched) {
-        valuesStamp[0] = time;
-        objToArray(changedValuesStamp[1], ([, newValue], valueId) =>
-          mapSet(valuesStamp[1], valueId, stampNew(time, newValue)),
-        );
-      }
+          stampUpdate(tableStampMap, tableHash, tableTime);
+          tablesHash ^= hasHashes
+            ? 0
+            : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
+              hashIdAndHash(tableId, tableStampMap[2]);
+        },
+      );
+      stampUpdate(tablesStampMap, tablesHash, tablesTime);
     }
+    mergeCellsOrValues(values, valuesStampMap, valuesChanges, hasHashes);
+    stampUpdate(
+      contentStampMap,
+      hasHashes
+        ? incomingContentOrChangesHash
+        : tablesStampMap[2] ^ valuesStampMap[2],
+      contentOrChangesTime,
+    );
+    return [tablesChanges, valuesChanges, 1];
   };
-  const postFinishTransaction = () =>
-    (transactionTime = finishTransactionMergeableChanges = void 0);
-  const merge = (mergeableStore2) => {
-    const mergeableContent = mergeableStore.getMergeableContent();
-    const mergeableContent2 = mergeableStore2.getMergeableContent();
-    mergeableStore2.applyMergeableChanges(mergeableContent);
-    return applyMergeableChanges(mergeableContent2);
+  const mergeCellsOrValues = (
+    things,
+    thingsStampMap,
+    thingsChanges,
+    hasHashes,
+  ) => {
+    const [thingsTime, thingsObj, incomingThingsHash] = things;
+    const [oldThingsTime, thingStampMaps, oldThingsHash] = thingsStampMap;
+    if (thingsTime) {
+      let thingsHash = hasHashes
+        ? incomingThingsHash
+        : oldThingsHash ^
+          (thingsTime > oldThingsTime
+            ? (oldThingsTime ? getHash(oldThingsTime) : 0) ^ getHash(thingsTime)
+            : 0);
+      objForEach(
+        thingsObj,
+        ([thingTime, thing, incomingThingHash], thingId) => {
+          const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
+            EMPTY_STRING,
+            void 0,
+            0,
+          ]);
+          const [oldThingTime, , oldThingHash] = thingStampMap;
+          if (thingTime > oldThingTime) {
+            stampUpdate(
+              thingStampMap,
+              hasHashes
+                ? incomingThingHash
+                : getHash(jsonString(thing ?? null) + ':' + thingTime),
+              thingTime,
+            );
+            thingStampMap[1] = thing;
+            thingsChanges[thingId] = thing;
+            thingsHash ^= hasHashes
+              ? 0
+              : hashIdAndHash(thingId, oldThingHash) ^
+                hashIdAndHash(thingId, thingStampMap[2]);
+          }
+        },
+      );
+      stampUpdate(thingsStampMap, thingsHash, thingsTime);
+    }
+    return [oldThingsHash, thingsStampMap[2]];
+  };
+  const preFinishTransaction = () => {
+    if (listening) {
+      transactionMergeableChanges = getTransactionMergeableChanges();
+      mergeContentOrChanges(transactionMergeableChanges);
+    }
   };
-  const getMergeableContent = () =>
-    mapStamp(contentStamp, ([tablesStamp, valuesStamp]) => [
-      mapStampMapToObj(tablesStamp, (rowsStamp) =>
-        mapStampMapToObj(rowsStamp, (cellsStamp) =>
-          mapStampMapToObj(cellsStamp, cloneStamp),
+  const postFinishTransaction = () =>
+    (transactionTime = transactionMergeableChanges = void 0);
+  const getId = () => id;
+  const getMergeableContent = () => [
+    contentStampMap[0],
+    [
+      stampMapToObjWithHash(contentStampMap[1][0], (tableStampMap) =>
+        stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
+          stampMapToObjWithHash(rowStampMap),
         ),
       ),
-      mapStampMapToObj(valuesStamp, cloneStamp),
-    ]);
-  const setMergeableContent = (mergeableContent) => {
-    disableListening(() =>
-      store.transaction(() => {
-        store.delTables().delValues();
-        contentStamp = newContentStamp();
-      }),
+      stampMapToObjWithHash(contentStampMap[1][1]),
+    ],
+    contentStampMap[2],
+  ];
+  const getMergeableContentHashes = () => [
+    contentStampMap[0],
+    [contentStampMap[1][0][2], contentStampMap[1][1][2]],
+  ];
+  const getMergeableTableHashes = () =>
+    mapToObj(contentStampMap[1][0][1], getStampHash);
+  const getMergeableTableIdsDiff = (relativeTo) => {
+    const tableIds = [];
+    mapForEach(contentStampMap[1][0][1], (tableId, [, , hash]) => {
+      if (hash !== relativeTo?.[tableId]) {
+        arrayPush(tableIds, tableId);
+      }
+    });
+    return tableIds;
+  };
+  const getMergeableRowHashes = (tablesDelta) =>
+    objNew(
+      arrayMap(tablesDelta, (tableId) => [
+        tableId,
+        mapToObj(mapGet(contentStampMap[1][0][1], tableId)?.[1], getStampHash),
+      ]),
     );
-    applyMergeableChanges(mergeableContent);
-    return mergeableStore;
+  const getMergeableRowIdsDiff = (relativeTo) =>
+    objMap(relativeTo, (rowHashes, tableId) => {
+      const rowIds = [];
+      mapForEach(
+        mapGet(contentStampMap[1][0][1], tableId)?.[1],
+        (rowId, [, , hash]) => {
+          if (hash !== rowHashes?.[rowId]) {
+            arrayPush(rowIds, rowId);
+          }
+        },
+      );
+      return rowIds;
+    });
+  const getMergeableCellHashes = (tableDelta) =>
+    objMap(tableDelta, (rowIds, tableId) =>
+      objNew(
+        arrayMap(rowIds, (rowId) => [
+          rowId,
+          mapToObj(
+            mapGet(mapGet(contentStampMap[1][0][1], tableId)?.[1], rowId)?.[1],
+            getStampHash,
+          ),
+        ]),
+      ),
+    );
+  const getMergeableTablesChanges = (relativeTo) => {
+    const [, [[tablesTime, tableStampMaps]]] = contentStampMap;
+    const tables = {};
+    objForEach(relativeTo, (rowCellHashes, tableId) =>
+      ifNotUndefined(
+        mapGet(tableStampMaps, tableId),
+        ([tableTime, rowStampMaps]) => {
+          const table = {};
+          objForEach(rowCellHashes, (cellHashes, rowId) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([rowTime, cellStampMaps]) => {
+                const row = mapToObj(
+                  cellStampMaps,
+                  stampClone,
+                  ([, , hash], cellId) => hash == cellHashes?.[cellId],
+                );
+                if (!objIsEmpty(row)) {
+                  table[rowId] = [rowTime, row];
+                }
+              },
+            ),
+          );
+          if (!objIsEmpty(table)) {
+            tables[tableId] = [tableTime, table];
+          }
+        },
+      ),
+    );
+    return [tablesTime, tables];
   };
+  const getMergeableValuesHashes = () =>
+    mapToObj(contentStampMap[1][1][1], getStampHash);
+  const getMergeableValuesChanges = (relativeTo) => [
+    contentStampMap[1][1][0],
+    mapToObj(
+      contentStampMap[1][1][1],
+      stampClone,
+      ([, , hash], valueId) => hash == relativeTo?.[valueId],
+    ),
+  ];
+  const setMergeableContent = (mergeableContent) =>
+    disableListening(() =>
+      validateMergeableContent(mergeableContent)
+        ? store.transaction(() => {
+            store.delTables().delValues();
+            contentStampMap = newContentStampMap();
+            seenHlc(mergeableContent[0]);
+            store.applyChanges(mergeContentOrChanges(mergeableContent, 1));
+          })
+        : 0,
+    );
   const getTransactionMergeableChanges = () => {
-    if (isUndefined(finishTransactionMergeableChanges)) {
+    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 [[, tableStamps], [, valuesStamp]] = mergeableChanges[1];
+      const mergeableChanges = [
+        time,
+        [
+          stampNewObj(objIsEmpty(changedCells) ? EMPTY_STRING : time),
+          stampNewObj(objIsEmpty(changedValues) ? EMPTY_STRING : time),
+          1,
+        ],
+      ];
+      const [[, tablesObj], [, valuesObj]] = mergeableChanges[1];
       objToArray(changedCells, (changedTable, tableId) => {
-        const [, rowStamps] = (tableStamps[tableId] = stampNewObj(time));
+        const [, rowsObj] = (tablesObj[tableId] = stampNewObj(time));
         objToArray(changedTable, (changedRow, rowId) => {
-          const [, cellStamps] = (rowStamps[rowId] = stampNewObj(time));
+          const [, cellsObj] = (rowsObj[rowId] = stampNewObj(time));
           objToArray(
             changedRow,
-            ([, newCell], cellId) =>
-              (cellStamps[cellId] = stampNew(time, newCell)),
+            ([, newCell], cellId) => (cellsObj[cellId] = [time, newCell]),
           );
         });
       });
       objToArray(
         changedValues,
-        ([, newValue], valueId) =>
-          (valuesStamp[valueId] = stampNew(time, newValue)),
+        ([, newValue], valueId) => (valuesObj[valueId] = [time, newValue]),
       );
       return mergeableChanges;
     }
-    return finishTransactionMergeableChanges;
+    return transactionMergeableChanges;
   };
-  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);
-      },
-    );
-    disableListening(() => store.applyChanges(changes));
-    return mergeableStore;
+  const applyMergeableChanges = (mergeableChanges) =>
+    disableListening(() => {
+      seenHlc(mergeableChanges[0]);
+      store.applyChanges(mergeContentOrChanges(mergeableChanges));
+    });
+  const merge = (mergeableStore2) => {
+    const mergeableChanges = getMergeableContent();
+    const mergeableChanges2 = mergeableStore2.getMergeableContent();
+    mergeableStore2.applyMergeableChanges(mergeableChanges);
+    return applyMergeableChanges(mergeableChanges2);
   };
   const mergeableStore = {
+    getId,
     getMergeableContent,
+    getMergeableContentHashes,
+    getMergeableTableHashes,
+    getMergeableTableIdsDiff,
+    getMergeableRowHashes,
+    getMergeableRowIdsDiff,
+    getMergeableCellHashes,
+    getMergeableTablesChanges,
+    getMergeableValuesHashes,
+    getMergeableValuesChanges,
     setMergeableContent,
     getTransactionMergeableChanges,
     applyMergeableChanges,