tinybase 5.0.0-beta.5 → 5.0.0-beta.7

package/lib/debug/tinybase.js

@@ -33,6 +33,7 @@ const strStartsWith = (str, prefix) => str.startsWith(prefix);
 const strEndsWith = (str, suffix) => str.endsWith(suffix);
 const strCharCodeAt = (str, position) => str.charCodeAt(position);
 
+const promise = Promise;
 const mathMax = Math.max;
 const mathMin = Math.min;
 const isFiniteNumber = isFinite;
@@ -48,6 +49,7 @@ const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
 const size = (arrayOrString) => arrayOrString.length;
 const test = (regex, subject) => regex.test(subject);
 const getUndefined = () => void 0;
+const promiseNew = (resolver) => new promise(resolver);
 
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
@@ -74,9 +76,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(
@@ -87,6 +87,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) => {
@@ -97,6 +99,8 @@ 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) => {
@@ -105,6 +109,23 @@ const objEnsure = (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);
@@ -141,24 +162,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) => {
@@ -197,6 +222,8 @@ const getCellOrValueType = (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)
@@ -1093,7 +1120,6 @@ const createMetrics = getCreateFunction((store) => {
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
-const isMergeable = (contentOrChanges) => isString(contentOrChanges?.[0]);
 const getStoreFunctions = (supportsMergeableStore, store) =>
   !supportsMergeableStore || isUndefined(store.getMergeableContent)
     ? [
@@ -1118,16 +1144,15 @@ const createCustomPersister = (
   delPersisterListener,
   onIgnoredError,
   supportsMergeableStore,
-  [getThing, thing] = [],
+  extra = {},
   scheduleId = [],
 ) => {
-  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = 0;
   let action;
-  let listeningHandle;
+  let autoLoadHandle;
+  let autoSaveListenerId;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
   const [isMergeableStore, getContent, getChanges, hasChanges] =
@@ -1163,55 +1188,51 @@ const createCustomPersister = (
     }
     return persister;
   };
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isString(contentOrChanges?.[0])
+      ? contentOrChanges?.[1][2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
   const persister = {
     load: async (initialTables, initialValues) =>
       await loadLock(async () => {
         try {
-          const content = await getPersisted();
-          (isMergeableStore && isMergeable(content)
-            ? store.setMergeableContent
-            : store.setContent)(content);
-        } catch {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
           store.setContent([initialTables, initialValues]);
         }
       }),
     startAutoLoad: async (initialTables = {}, initialValues = {}) => {
-      persister.stopAutoLoad();
-      await persister.load(initialTables, initialValues);
-      listening = 1;
-      listeningHandle = addPersisterListener(
+      await persister.stopAutoLoad().load(initialTables, initialValues);
+      autoLoadHandle = addPersisterListener(
         async (getContent2, getChanges2) => {
-          if (getChanges2) {
-            const changes = getChanges2();
-            await loadLock(async () =>
-              (isMergeableStore && isMergeable(changes)
-                ? store.applyMergeableChanges
-                : store.applyChanges)(changes),
-            );
-          } else {
-            await loadLock(async () => {
-              try {
-                const content = getContent2?.() ?? (await getPersisted());
-                (isMergeableStore && isMergeable(content)
-                  ? store.setMergeableContent
-                  : store.setContent)(content);
-              } catch (error) {
-                onIgnoredError?.(error);
-              }
-            });
-          }
+          const changes = getChanges2?.();
+          await loadLock(async () => {
+            try {
+              setContentOrChanges(
+                changes ?? getContent2?.() ?? (await getPersisted()),
+              );
+            } catch (error) {
+              onIgnoredError?.(error);
+            }
+          });
         },
       );
       return persister;
     },
     stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
+      if (autoLoadHandle) {
+        delPersisterListener(autoLoadHandle);
+        autoLoadHandle = void 0;
       }
       return persister;
     },
+    isAutoLoading: () => !isUndefined(autoLoadHandle),
     save: async (getChanges2) => {
       /* istanbul ignore else */
       if (loadSave != 1) {
@@ -1233,7 +1254,7 @@ const createCustomPersister = (
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(() => {
+      autoSaveListenerId = store.addDidFinishTransactionListener(() => {
         const changes = getChanges();
         if (hasChanges(changes)) {
           persister.save(() => changes);
@@ -1242,10 +1263,11 @@ const createCustomPersister = (
       return persister;
     },
     stopAutoSave: () => {
-      ifNotUndefined(listenerId, store.delListener);
-      listenerId = void 0;
+      ifNotUndefined(autoSaveListenerId, store.delListener);
+      autoSaveListenerId = void 0;
       return persister;
     },
+    isAutoSaving: () => !isUndefined(autoSaveListenerId),
     schedule: async (...actions) => {
       arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
       await run();
@@ -1254,13 +1276,262 @@ const createCustomPersister = (
     getStore: () => store,
     destroy: () => persister.stopAutoLoad().stopAutoSave(),
     getStats: () => ({loads, saves}),
+    ...extra,
   };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
   return objFreeze(persister);
 };
 
+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 MASK6 = 63;
+const SHIFT36 = 2 ** 36;
+const SHIFT30 = 2 ** 30;
+const SHIFT24 = 2 ** 24;
+const SHIFT18 = 2 ** 18;
+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 encodeHlc = (logicalTime42, counter24, clientHash30) =>
+  toB64(logicalTime42 / SHIFT36) +
+  toB64(logicalTime42 / SHIFT30) +
+  toB64(logicalTime42 / SHIFT24) +
+  toB64(logicalTime42 / SHIFT18) +
+  toB64(logicalTime42 / SHIFT12) +
+  toB64(logicalTime42 / SHIFT6) +
+  toB64(logicalTime42) +
+  toB64(counter24 / SHIFT18) +
+  toB64(counter24 / SHIFT12) +
+  toB64(counter24 / SHIFT6) +
+  toB64(counter24) +
+  toB64(clientHash30 / SHIFT24) +
+  toB64(clientHash30 / SHIFT18) +
+  toB64(clientHash30 / SHIFT12) +
+  toB64(clientHash30 / SHIFT6) +
+  toB64(clientHash30);
+const decodeHlc = (hlc16) => [
+  fromB64(hlc16, 0) * SHIFT36 +
+    fromB64(hlc16, 1) * SHIFT30 +
+    fromB64(hlc16, 2) * SHIFT24 +
+    fromB64(hlc16, 3) * SHIFT18 +
+    fromB64(hlc16, 4) * SHIFT12 +
+    fromB64(hlc16, 5) * SHIFT6 +
+    fromB64(hlc16, 6),
+  fromB64(hlc16, 7) * SHIFT18 +
+    fromB64(hlc16, 8) * SHIFT12 +
+    fromB64(hlc16, 9) * SHIFT6 +
+    fromB64(hlc16, 10),
+  fromB64(hlc16, 11) * SHIFT24 +
+    fromB64(hlc16, 12) * SHIFT18 +
+    fromB64(hlc16, 13) * SHIFT12 +
+    fromB64(hlc16, 14) * SHIFT6 +
+    fromB64(hlc16, 15),
+];
+const getHlcFunctions = (uniqueId) => {
+  let logicalTime = 0;
+  let lastCounter = -1;
+  const uniqueIdHash = getHash(uniqueId);
+  const getHlc = () => {
+    seenHlc();
+    return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
+  };
+  const seenHlc = (hlc) => {
+    const previousLogicalTime = logicalTime;
+    const [remoteLogicalTime, remoteCounter] =
+      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeHlc(hlc);
+    logicalTime = mathMax(
+      previousLogicalTime,
+      remoteLogicalTime,
+      globalThis.HLC_TIME ?? Date.now(),
+    );
+    lastCounter =
+      logicalTime == previousLogicalTime
+        ? logicalTime == remoteLogicalTime
+          ? mathMax(lastCounter, remoteCounter)
+          : lastCounter
+        : logicalTime == remoteLogicalTime
+          ? remoteCounter
+          : -1;
+  };
+  return [getHlc, seenHlc];
+};
+
+const RESPONSE = 0;
+const CONTENT_HASHES = 1;
+const GET_CONTENT_HASHES = 2;
+const GET_TABLE_IDS_DIFF = 3;
+const GET_ROW_IDS_DIFF = 4;
+const GET_TABLES_CHANGES = 5;
+const GET_VALUES_CHANGES = 6;
+const createCustomSynchronizer = (
+  store,
+  send,
+  onReceive,
+  destroy,
+  requestTimeoutSeconds = 1,
+  onIgnoredError,
+) => {
+  let persisterListener;
+  let sends = 0;
+  let receives = 0;
+  const [getHlc] = getHlcFunctions(store.getId());
+  const pendingRequests = mapNew();
+  onReceive((fromClientId, requestId, messageType, messageBody) => {
+    {
+      receives++;
+    }
+    if (messageType == RESPONSE) {
+      ifNotUndefined(
+        mapGet(pendingRequests, requestId),
+        ([toClientId, handleResponse]) =>
+          isUndefined(toClientId) || toClientId == fromClientId
+            ? handleResponse(messageBody, fromClientId)
+            : /* istanbul ignore next */
+              0,
+      );
+    } else if (messageType == CONTENT_HASHES && persister.isAutoLoading()) {
+      getChangesFromOtherStore(fromClientId, messageBody).then((changes) =>
+        persisterListener?.(void 0, () => changes),
+      );
+    } else {
+      ifNotUndefined(
+        messageType == GET_CONTENT_HASHES && persister.isAutoSaving()
+          ? store.getMergeableContentHashes()
+          : messageType == GET_TABLE_IDS_DIFF
+            ? store.getMergeableTableIdsDiff(messageBody)
+            : messageType == GET_ROW_IDS_DIFF
+              ? store.getMergeableRowIdsDiff(messageBody)
+              : messageType == GET_TABLES_CHANGES
+                ? store.getMergeableTablesChanges(messageBody)
+                : messageType == GET_VALUES_CHANGES
+                  ? store.getMergeableValuesChanges(messageBody)
+                  : void 0,
+        (response) => {
+          {
+            sends++;
+          }
+          send(fromClientId, requestId, RESPONSE, response);
+        },
+      );
+    }
+  });
+  const request = async (toClientId, messageType, messageBody = EMPTY_STRING) =>
+    promiseNew((resolve, reject) => {
+      const requestId = getHlc();
+      const timeout = setTimeout(() => {
+        collDel(pendingRequests, requestId);
+        reject(
+          `No response from ${toClientId ?? 'anyone'} to '${messageType}'`,
+        );
+      }, requestTimeoutSeconds * 1e3);
+      mapSet(pendingRequests, requestId, [
+        toClientId,
+        (response, fromClientId) => {
+          clearTimeout(timeout);
+          collDel(pendingRequests, requestId);
+          resolve([response, fromClientId]);
+        },
+      ]);
+      {
+        sends++;
+      }
+      send(toClientId, requestId, messageType, messageBody);
+    });
+  const getChangesFromOtherStore = async (
+    otherClientId = null,
+    otherContentHashes,
+  ) => {
+    if (isUndefined(otherContentHashes)) {
+      [otherContentHashes, otherClientId] = await request(
+        otherClientId,
+        GET_CONTENT_HASHES,
+      );
+    }
+    const [otherContentTime, [otherTablesHash, otherValuesHash]] =
+      otherContentHashes;
+    const [, [tablesHash, valuesHash]] = store.getMergeableContentHashes();
+    const changes = [EMPTY_STRING, [[EMPTY_STRING, {}], [EMPTY_STRING, {}], 1]];
+    if (tablesHash != otherTablesHash) {
+      changes[0] = otherContentTime;
+      changes[1][0] = (
+        await request(
+          otherClientId,
+          GET_TABLES_CHANGES,
+          store.getMergeableCellHashes(
+            (
+              await request(
+                otherClientId,
+                GET_ROW_IDS_DIFF,
+                store.getMergeableRowHashes(
+                  (
+                    await request(
+                      otherClientId,
+                      GET_TABLE_IDS_DIFF,
+                      store.getMergeableTableHashes(),
+                    )
+                  )[0],
+                ),
+              )
+            )[0],
+          ),
+        )
+      )[0];
+    }
+    if (valuesHash != otherValuesHash) {
+      changes[0] = otherContentTime;
+      changes[1][1] = (
+        await request(
+          otherClientId,
+          GET_VALUES_CHANGES,
+          store.getMergeableValuesHashes(),
+        )
+      )[0];
+    }
+    return changes;
+  };
+  const getPersisted = async () => {
+    const changes = await getChangesFromOtherStore();
+    return changes[0] != EMPTY_STRING ? changes : void 0;
+  };
+  const setPersisted = async () => {
+    {
+      sends++;
+    }
+    send(null, null, CONTENT_HASHES, store.getMergeableContentHashes());
+  };
+  const addPersisterListener = (listener) => (persisterListener = listener);
+  const delPersisterListener = () => (persisterListener = void 0);
+  const persister = createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    true,
+    {
+      startSync: async () =>
+        await (await persister.startAutoLoad()).startAutoSave(),
+      stopSync: () => persister.stopAutoLoad().stopAutoSave(),
+      destroy: () => {
+        destroy();
+        return persister.stopSync();
+      },
+      getSynchronizerStats: () => ({sends, receives}),
+    },
+  );
+  return persister;
+};
+
 const createQueries = getCreateFunction((store) => {
   const createStore = store.createStore;
   const preStore = createStore();
@@ -1909,36 +2180,29 @@ const createRelationships = getCreateFunction((store) => {
   return objFreeze(relationships);
 });
 
-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 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 updateHashStamp = (hashStamp, hash, time) => {
-  hashStamp[2] = hash >>> 0;
-  if (time > hashStamp[0]) {
-    hashStamp[0] = time;
+const stampUpdate = (stamp, hash, time) => {
+  stamp[2] = hash >>> 0;
+  if (time > stamp[0]) {
+    stamp[0] = time;
   }
 };
-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 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 pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
@@ -1952,18 +2216,6 @@ const jsonString = (obj) =>
   );
 const jsonParse = JSON.parse;
 
-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,
@@ -2023,13 +2275,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];
@@ -2042,18 +2294,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(
@@ -2080,7 +2332,7 @@ const createStore = () => {
         ? cellInvalid(tableId, rowId, cellId, cell)
         : cell;
   const validateValues = (values, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
       (value, valueId) =>
         ifNotUndefined(
@@ -2923,17 +3175,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),
@@ -3266,76 +3521,6 @@ const createStore = () => {
   return objFreeze(store);
 };
 
-const MASK6 = 63;
-const SHIFT36 = 2 ** 36;
-const SHIFT30 = 2 ** 30;
-const SHIFT24 = 2 ** 24;
-const SHIFT18 = 2 ** 18;
-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 encodeHlc = (logicalTime42, counter24, clientHash30) =>
-  toB64(logicalTime42 / SHIFT36) +
-  toB64(logicalTime42 / SHIFT30) +
-  toB64(logicalTime42 / SHIFT24) +
-  toB64(logicalTime42 / SHIFT18) +
-  toB64(logicalTime42 / SHIFT12) +
-  toB64(logicalTime42 / SHIFT6) +
-  toB64(logicalTime42) +
-  toB64(counter24 / SHIFT18) +
-  toB64(counter24 / SHIFT12) +
-  toB64(counter24 / SHIFT6) +
-  toB64(counter24) +
-  toB64(clientHash30 / SHIFT24) +
-  toB64(clientHash30 / SHIFT18) +
-  toB64(clientHash30 / SHIFT12) +
-  toB64(clientHash30 / SHIFT6) +
-  toB64(clientHash30);
-const decodeHlc = (hlc16) => [
-  fromB64(hlc16, 0) * SHIFT36 +
-    fromB64(hlc16, 1) * SHIFT30 +
-    fromB64(hlc16, 2) * SHIFT24 +
-    fromB64(hlc16, 3) * SHIFT18 +
-    fromB64(hlc16, 4) * SHIFT12 +
-    fromB64(hlc16, 5) * SHIFT6 +
-    fromB64(hlc16, 6),
-  fromB64(hlc16, 7) * SHIFT18 +
-    fromB64(hlc16, 8) * SHIFT12 +
-    fromB64(hlc16, 9) * SHIFT6 +
-    fromB64(hlc16, 10),
-  fromB64(hlc16, 11) * SHIFT24 +
-    fromB64(hlc16, 12) * SHIFT18 +
-    fromB64(hlc16, 13) * SHIFT12 +
-    fromB64(hlc16, 14) * SHIFT6 +
-    fromB64(hlc16, 15),
-];
-const getHlcFunctions = (uniqueId) => {
-  let logicalTime = 0;
-  let lastCounter = -1;
-  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());
-    lastCounter =
-      logicalTime == previousLogicalTime
-        ? logicalTime == remoteLogicalTime
-          ? mathMax(lastCounter, remoteCounter)
-          : lastCounter
-        : logicalTime == remoteLogicalTime
-          ? remoteCounter
-          : -1;
-  };
-  return [getHlc, seenHlc];
-};
-
 const LISTENER_ARGS = {
   HasTable: 1,
   Table: 1,
@@ -3354,14 +3539,54 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
-const newContentHsm = (time = EMPTY_STRING) => [
+const newContentStampMap = (time = EMPTY_STRING) => [
   time,
-  [hashStampNewMap(time), hashStampNewMap(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 contentHsm = newContentHsm();
+  let contentStampMap = newContentStampMap();
   let transactionTime;
   let transactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
@@ -3371,6 +3596,7 @@ const createMergeableStore = (id) => {
     listening = 0;
     actions();
     listening = wasListening;
+    return mergeableStore;
   };
   const mergeContentOrChanges = (contentOrChanges, hasHashes = 0) => {
     const tablesChanges = {};
@@ -3380,8 +3606,8 @@ const createMergeableStore = (id) => {
       [[tablesTime, tablesObj, incomingTablesHash], values],
       incomingContentOrChangesHash,
     ] = contentOrChanges;
-    const [, [tablesHsm, valuesHsm]] = contentHsm;
-    const [oldTablesTime, tableHsms, oldTablesHash] = tablesHsm;
+    const [, [tablesStampMap, valuesStampMap]] = contentStampMap;
+    const [oldTablesTime, tableStampMaps, oldTablesHash] = tablesStampMap;
     if (tablesTime) {
       let tablesHash = hasHashes
         ? incomingTablesHash
@@ -3392,8 +3618,8 @@ const createMergeableStore = (id) => {
       objForEach(
         tablesObj,
         ([tableTime, rowsObj, incomingTableHash], tableId) => {
-          const tableHsm = mapEnsure(tableHsms, tableId, hashStampNewMap);
-          const [oldTableTime, rowHsms, oldTableHash] = tableHsm;
+          const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
+          const [oldTableTime, rowStampMaps, oldTableHash] = tableStampMap;
           let tableHash = hasHashes
             ? incomingTableHash
             : oldTableHash ^
@@ -3404,7 +3630,7 @@ const createMergeableStore = (id) => {
           objForEach(rowsObj, (row, rowId) => {
             const [oldRowHash, rowHash] = mergeCellsOrValues(
               row,
-              mapEnsure(rowHsms, rowId, hashStampNewMap),
+              mapEnsure(rowStampMaps, rowId, stampNewMap),
               objEnsure(
                 objEnsure(tablesChanges, tableId, objNew),
                 rowId,
@@ -3417,26 +3643,33 @@ const createMergeableStore = (id) => {
               : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
                 hashIdAndHash(rowId, rowHash);
           });
-          updateHashStamp(tableHsm, tableHash, tableTime);
+          stampUpdate(tableStampMap, tableHash, tableTime);
           tablesHash ^= hasHashes
             ? 0
             : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
-              hashIdAndHash(tableId, tableHsm[2]);
+              hashIdAndHash(tableId, tableStampMap[2]);
         },
       );
-      updateHashStamp(tablesHsm, tablesHash, tablesTime);
+      stampUpdate(tablesStampMap, tablesHash, tablesTime);
     }
-    mergeCellsOrValues(values, valuesHsm, valuesChanges, hasHashes);
-    updateHashStamp(
-      contentHsm,
-      hasHashes ? incomingContentOrChangesHash : tablesHsm[2] ^ valuesHsm[2],
+    mergeCellsOrValues(values, valuesStampMap, valuesChanges, hasHashes);
+    stampUpdate(
+      contentStampMap,
+      hasHashes
+        ? incomingContentOrChangesHash
+        : tablesStampMap[2] ^ valuesStampMap[2],
       contentOrChangesTime,
     );
-    return [tablesChanges, valuesChanges];
+    return [tablesChanges, valuesChanges, 1];
   };
-  const mergeCellsOrValues = (things, thingsHsm, thingsChanges, hasHashes) => {
+  const mergeCellsOrValues = (
+    things,
+    thingsStampMap,
+    thingsChanges,
+    hasHashes,
+  ) => {
     const [thingsTime, thingsObj, incomingThingsHash] = things;
-    const [oldThingsTime, thingHsms, oldThingsHash] = thingsHsm;
+    const [oldThingsTime, thingStampMaps, oldThingsHash] = thingsStampMap;
     if (thingsTime) {
       let thingsHash = hasHashes
         ? incomingThingsHash
@@ -3447,28 +3680,32 @@ const createMergeableStore = (id) => {
       objForEach(
         thingsObj,
         ([thingTime, thing, incomingThingHash], thingId) => {
-          const thingHsm = mapEnsure(thingHsms, thingId, hashStampNewThing);
-          const [oldThingTime, , oldThingHash] = thingHsm;
+          const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
+            EMPTY_STRING,
+            void 0,
+            0,
+          ]);
+          const [oldThingTime, , oldThingHash] = thingStampMap;
           if (thingTime > oldThingTime) {
-            updateHashStamp(
-              thingHsm,
+            stampUpdate(
+              thingStampMap,
               hasHashes
                 ? incomingThingHash
                 : getHash(jsonString(thing ?? null) + ':' + thingTime),
               thingTime,
             );
-            thingHsm[1] = thing;
+            thingStampMap[1] = thing;
             thingsChanges[thingId] = thing;
             thingsHash ^= hasHashes
               ? 0
               : hashIdAndHash(thingId, oldThingHash) ^
-                hashIdAndHash(thingId, thingHsm[2]);
+                hashIdAndHash(thingId, thingStampMap[2]);
           }
         },
       );
-      updateHashStamp(thingsHsm, thingsHash, thingsTime);
+      stampUpdate(thingsStampMap, thingsHash, thingsTime);
     }
-    return [oldThingsHash, thingsHsm[2]];
+    return [oldThingsHash, thingsStampMap[2]];
   };
   const preFinishTransaction = () => {
     if (listening) {
@@ -3478,26 +3715,118 @@ const createMergeableStore = (id) => {
   };
   const postFinishTransaction = () =>
     (transactionTime = transactionMergeableChanges = void 0);
-  const getMergeableContent = () =>
-    hashStampMap(contentHsm, ([tables, values]) => [
-      hashStampMapToObj(tables, (table) =>
-        hashStampMapToObj(table, (row) => hashStampMapToObj(row)),
+  const getId = () => id;
+  const getMergeableContent = () => [
+    contentStampMap[0],
+    [
+      stampMapToObjWithHash(contentStampMap[1][0], (tableStampMap) =>
+        stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
+          stampMapToObjWithHash(rowStampMap),
+        ),
       ),
-      hashStampMapToObj(values),
-    ]);
-  const setMergeableContent = (mergeableContent) => {
-    disableListening(() =>
-      store.transaction(() => {
-        store.delTables().delValues();
-        contentHsm = newContentHsm();
-      }),
+      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),
+      ]),
     );
-    seenHlc(mergeableContent[0]);
-    disableListening(() =>
-      store.applyChanges(mergeContentOrChanges(mergeableContent, 1)),
+  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,
+          ),
+        ]),
+      ),
     );
-    return mergeableStore;
+  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(transactionMergeableChanges)) {
       const [, , changedCells, , changedValues] = store.getTransactionLog();
@@ -3505,10 +3834,14 @@ const createMergeableStore = (id) => {
         !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 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 [, rowsObj] = (tablesObj[tableId] = stampNewObj(time));
@@ -3516,60 +3849,45 @@ const createMergeableStore = (id) => {
           const [, cellsObj] = (rowsObj[rowId] = stampNewObj(time));
           objToArray(
             changedRow,
-            ([, newCell], cellId) =>
-              (cellsObj[cellId] = stampNew(time, newCell)),
+            ([, newCell], cellId) => (cellsObj[cellId] = [time, newCell]),
           );
         });
       });
       objToArray(
         changedValues,
-        ([, newValue], valueId) =>
-          (valuesObj[valueId] = stampNew(time, newValue)),
+        ([, newValue], valueId) => (valuesObj[valueId] = [time, newValue]),
       );
       return mergeableChanges;
     }
     return transactionMergeableChanges;
   };
-  const applyMergeableChanges = (mergeableChanges) => {
-    seenHlc(mergeableChanges[0]);
-    disableListening(() =>
-      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
-    );
-    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 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 = {
+    getId,
     getMergeableContent,
+    getMergeableContentHashes,
+    getMergeableTableHashes,
+    getMergeableTableIdsDiff,
+    getMergeableRowHashes,
+    getMergeableRowIdsDiff,
+    getMergeableCellHashes,
+    getMergeableTablesChanges,
+    getMergeableValuesHashes,
+    getMergeableValuesChanges,
     setMergeableContent,
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
-    getContentHash,
-    getTablesHash,
-    getTableHash,
-    getRowHash,
-    getCellHash,
-    getValuesHash,
-    getValueHash,
   };
   store.setInternalListeners(preFinishTransaction, postFinishTransaction);
   objToArray(
@@ -3601,6 +3919,7 @@ const createMergeableStore = (id) => {
 export {
   createCheckpoints,
   createCustomPersister,
+  createCustomSynchronizer,
   createIndexes,
   createMergeableStore,
   createMetrics,