tinybase 6.2.0-beta.3 → 6.2.0

package/omni/with-schemas/index.js

@@ -176,8 +176,8 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objEntries = object.entries;
 const objFrozen = object.isFrozen;
+const objEntries = object.entries;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -859,16 +859,60 @@ const getUniqueId$1 = (length = 16) =>
     '',
   );
 
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithMap = (obj) =>
+  jsonString(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
+  );
+const jsonStringWithUndefined = (obj) =>
+  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+const jsonParseWithUndefined = (str) =>
+  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
+
 const textEncoder = /* @__PURE__ */ new GLOBAL.TextEncoder();
-const getHash = (value) => {
+const getHash = (string) => {
   let hash = 2166136261;
-  arrayForEach(textEncoder.encode(value), (char) => {
+  arrayForEach(textEncoder.encode(string), (char) => {
     hash ^= char;
     hash +=
       (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
   });
   return hash >>> 0;
 };
+const addOrRemoveHash = (hash1, hash2) => (hash1 ^ hash2) >>> 0;
+const getValuesHash = (valueHashes) =>
+  arrayReduce(
+    objEntries(valueHashes),
+    (valuesHash, [valueId, valueHash]) =>
+      addOrRemoveHash(
+        valuesHash,
+        getValueInValuesHash(valueId, valueHash) ^
+          getValueInValuesHash(valueId, 0),
+        // legacy v5; remove in v7
+      ),
+    0,
+    // legacy v5; valuesHlc in v7?
+  );
+const getValueInValuesHash = (valueId, valueHash) =>
+  getHash(valueId + ':' + valueHash);
+const getValueHash = (value, valueHlc) =>
+  getHash(jsonStringWithMap(value ?? null) + ':' + valueHlc);
+const getCellHash = getValueHash;
+const getCellInRowHash = getValueInValuesHash;
+const getRowHash = getValuesHash;
+const getRowInTableHash = getValueInValuesHash;
+const getTableHash = (rowHashes) =>
+  // alias to getValuesHash in v7
+  arrayReduce(
+    objEntries(rowHashes),
+    (valuesHash, [rowId, rowHash]) =>
+      addOrRemoveHash(valuesHash, getValueInValuesHash(rowId, rowHash)),
+    0,
+    // legacy v5; rowHlc in v7?
+  );
+const getTableInTablesHash = getValueInValuesHash;
+const getTablesHash = getTableHash;
 
 const SHIFT36 = 2 ** 36;
 const SHIFT30 = 2 ** 30;
@@ -1164,42 +1208,30 @@ const createIndexes = getCreateFunction((store) => {
   return objFreeze(indexes);
 });
 
-const jsonString = JSON.stringify;
-const jsonParse = JSON.parse;
-const jsonStringWithMap = (obj) =>
-  jsonString(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
-  );
-const jsonStringWithUndefined = (obj) =>
-  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
-const jsonParseWithUndefined = (str) =>
-  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
-
-const stampClone = ([value, time]) => stampNew(value, time);
-const stampCloneWithHash = ([value, time, hash]) => [value, time, hash];
-const stampNew = (value, time) => (time ? [value, time] : [value]);
-const stampNewWithHash = (value, time, hash) => [value, time, hash];
+const stampClone = ([value, hlc]) => stampNew(value, hlc);
+const stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];
+const stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);
+const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
 const getStampHash = (stamp) => stamp[2];
-const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
-const replaceTimeHash = (oldTime, newTime) =>
-  newTime > oldTime ? (oldTime ? getHash(oldTime) : 0) ^ getHash(newTime) : 0;
-const getLatestTime = (time1, time2) =>
+const replaceHlcHash = (oldHlc, newHlc) =>
+  newHlc > oldHlc ? (oldHlc ? getHash(oldHlc) : 0) ^ getHash(newHlc) : 0;
+const getLatestHlc = (hlc1, hlc2) =>
   /* istanbul ignore next */
-  ((time1 ?? '') > (time2 ?? '') ? time1 : time2) ?? '';
-const stampUpdate = (stamp, time, hash) => {
-  if (time > stamp[1]) {
-    stamp[1] = time;
+  ((hlc1 ?? '') > (hlc2 ?? '') ? hlc1 : hlc2) ?? '';
+const stampUpdate = (stamp, hlc, hash) => {
+  if (hlc > stamp[1]) {
+    stamp[1] = hlc;
   }
   stamp[2] = hash >>> 0;
 };
-const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
-const stampNewMap = (time = EMPTY_STRING) => [mapNew(), time, 0];
+const stampNewObj = (hlc = EMPTY_STRING) => stampNew(objNew(), hlc);
+const stampNewMap = (hlc = EMPTY_STRING) => [mapNew(), hlc, 0];
 const stampMapToObjWithHash = (
-  [map, time, hash],
+  [map, hlc, hash],
   mapper = stampCloneWithHash,
-) => [mapToObj(map, mapper), time, hash];
-const stampMapToObjWithoutHash = ([map, time], mapper = stampClone) =>
-  stampNew(mapToObj(map, mapper), time);
+) => [mapToObj(map, mapper), hlc, hash];
+const stampMapToObjWithoutHash = ([map, hlc], mapper = stampClone) =>
+  stampNew(mapToObj(map, mapper), hlc);
 const stampValidate = (stamp, validateThing) =>
   isArray(stamp) &&
   size(stamp) == 3 &&
@@ -2644,25 +2676,25 @@ const createMergeableStore = (uniqueId, getNow) => {
     const tablesChanges = {};
     const valuesChanges = {};
     const [
-      [tablesObj, incomingTablesTime = EMPTY_STRING, incomingTablesHash = 0],
+      [tablesObj, incomingTablesHlc = EMPTY_STRING, incomingTablesHash = 0],
       values,
     ] = contentOrChanges;
     const [tablesStampMap, valuesStampMap] = contentStampMap;
-    const [tableStampMaps, oldTablesTime, oldTablesHash] = tablesStampMap;
+    const [tableStampMaps, oldTablesHlc, oldTablesHash] = tablesStampMap;
     let tablesHash = isContent ? incomingTablesHash : oldTablesHash;
-    let tablesTime = incomingTablesTime;
+    let tablesHlc = incomingTablesHlc;
     objForEach(
       tablesObj,
       (
-        [rowsObj, incomingTableTime = EMPTY_STRING, incomingTableHash = 0],
+        [rowsObj, incomingTableHlc = EMPTY_STRING, incomingTableHash = 0],
         tableId,
       ) => {
         const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
-        const [rowStampMaps, oldTableTime, oldTableHash] = tableStampMap;
+        const [rowStampMaps, oldTableHlc, oldTableHash] = tableStampMap;
         let tableHash = isContent ? incomingTableHash : oldTableHash;
-        let tableTime = incomingTableTime;
+        let tableHlc = incomingTableHlc;
         objForEach(rowsObj, (row, rowId) => {
-          const [rowTime, oldRowHash, rowHash] = mergeCellsOrValues(
+          const [rowHlc, oldRowHash, rowHash] = mergeCellsOrValues(
             row,
             mapEnsure(rowStampMaps, rowId, stampNewMap),
             objEnsure(objEnsure(tablesChanges, tableId, objNew), rowId, objNew),
@@ -2670,32 +2702,36 @@ const createMergeableStore = (uniqueId, getNow) => {
           );
           tableHash ^= isContent
             ? 0
-            : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
-              hashIdAndHash(rowId, rowHash);
-          tableTime = getLatestTime(tableTime, rowTime);
+            : addOrRemoveHash(
+                oldRowHash ? getValueInValuesHash(rowId, oldRowHash) : 0,
+                getValueInValuesHash(rowId, rowHash),
+              );
+          tableHlc = getLatestHlc(tableHlc, rowHlc);
         });
         tableHash ^= isContent
           ? 0
-          : replaceTimeHash(oldTableTime, incomingTableTime);
-        stampUpdate(tableStampMap, incomingTableTime, tableHash);
+          : replaceHlcHash(oldTableHlc, incomingTableHlc);
+        stampUpdate(tableStampMap, incomingTableHlc, tableHash);
         tablesHash ^= isContent
           ? 0
-          : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
-            hashIdAndHash(tableId, tableStampMap[2]);
-        tablesTime = getLatestTime(tablesTime, tableTime);
+          : addOrRemoveHash(
+              oldTableHash ? getValueInValuesHash(tableId, oldTableHash) : 0,
+              getValueInValuesHash(tableId, tableStampMap[2]),
+            );
+        tablesHlc = getLatestHlc(tablesHlc, tableHlc);
       },
     );
     tablesHash ^= isContent
       ? 0
-      : replaceTimeHash(oldTablesTime, incomingTablesTime);
-    stampUpdate(tablesStampMap, incomingTablesTime, tablesHash);
-    const [valuesTime] = mergeCellsOrValues(
+      : replaceHlcHash(oldTablesHlc, incomingTablesHlc);
+    stampUpdate(tablesStampMap, incomingTablesHlc, tablesHash);
+    const [valuesHlc] = mergeCellsOrValues(
       values,
       valuesStampMap,
       valuesChanges,
       isContent,
     );
-    seenHlc(getLatestTime(tablesTime, valuesTime));
+    seenHlc(getLatestHlc(tablesHlc, valuesHlc));
     return [tablesChanges, valuesChanges, 1];
   };
   const mergeCellsOrValues = (
@@ -2706,44 +2742,44 @@ const createMergeableStore = (uniqueId, getNow) => {
   ) => {
     const [
       thingsObj,
-      incomingThingsTime = EMPTY_STRING,
+      incomingThingsHlc = EMPTY_STRING,
       incomingThingsHash = 0,
     ] = things;
-    const [thingStampMaps, oldThingsTime, oldThingsHash] = thingsStampMap;
-    let thingsTime = incomingThingsTime;
+    const [thingStampMaps, oldThingsHlc, oldThingsHash] = thingsStampMap;
+    let thingsHlc = incomingThingsHlc;
     let thingsHash = isContent ? incomingThingsHash : oldThingsHash;
     objForEach(
       thingsObj,
-      ([thing, thingTime = EMPTY_STRING, incomingThingHash = 0], thingId) => {
+      ([thing, thingHlc = EMPTY_STRING, incomingThingHash = 0], thingId) => {
         const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
           void 0,
           EMPTY_STRING,
           0,
         ]);
-        const [, oldThingTime, oldThingHash] = thingStampMap;
-        if (!oldThingTime || thingTime > oldThingTime) {
+        const [, oldThingHlc, oldThingHash] = thingStampMap;
+        if (!oldThingHlc || thingHlc > oldThingHlc) {
           stampUpdate(
             thingStampMap,
-            thingTime,
-            isContent
-              ? incomingThingHash
-              : getHash(jsonStringWithMap(thing ?? null) + ':' + thingTime),
+            thingHlc,
+            isContent ? incomingThingHash : getValueHash(thing, thingHlc),
           );
           thingStampMap[0] = thing;
           thingsChanges[thingId] = thing;
           thingsHash ^= isContent
             ? 0
-            : hashIdAndHash(thingId, oldThingHash) ^
-              hashIdAndHash(thingId, thingStampMap[2]);
-          thingsTime = getLatestTime(thingsTime, thingTime);
+            : addOrRemoveHash(
+                getValueInValuesHash(thingId, oldThingHash),
+                getValueInValuesHash(thingId, thingStampMap[2]),
+              );
+          thingsHlc = getLatestHlc(thingsHlc, thingHlc);
         }
       },
     );
     thingsHash ^= isContent
       ? 0
-      : replaceTimeHash(oldThingsTime, incomingThingsTime);
-    stampUpdate(thingsStampMap, incomingThingsTime, thingsHash);
-    return [thingsTime, oldThingsHash, thingsStampMap[2]];
+      : replaceHlcHash(oldThingsHlc, incomingThingsHlc);
+    stampUpdate(thingsStampMap, incomingThingsHlc, thingsHash);
+    return [thingsHlc, oldThingsHash, thingsStampMap[2]];
   };
   const preStartTransaction = noop;
   const preFinishTransaction = noop;
@@ -2815,13 +2851,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     const differingTableHashes = {};
     mapForEach(
       contentStampMap[0][0],
-      (tableId, [tableStampMap, tableTime, hash]) =>
+      (tableId, [tableStampMap, tableHlc, hash]) =>
         objHas(otherTableHashes, tableId)
           ? hash != otherTableHashes[tableId]
             ? (differingTableHashes[tableId] = hash)
             : 0
           : (newTables[0][tableId] = stampMapToObjWithoutHash(
-              [tableStampMap, tableTime],
+              [tableStampMap, tableHlc],
               (rowStampMap) => stampMapToObjWithoutHash(rowStampMap),
             )),
     );
@@ -2850,13 +2886,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
       mapForEach(
         mapGet(contentStampMap[0][0], tableId)?.[0],
-        (rowId, [rowStampMap, rowTime, hash]) =>
+        (rowId, [rowStampMap, rowHlc, hash]) =>
           objHas(otherRowHashes, rowId)
             ? hash !== otherRowHashes[rowId]
               ? (objEnsure(differingRowHashes, tableId, objNew)[rowId] = hash)
               : 0
             : (objEnsure(newRows[0], tableId, stampNewObj)[0][rowId] =
-                stampMapToObjWithoutHash([rowStampMap, rowTime])),
+                stampMapToObjWithoutHash([rowStampMap, rowHlc])),
       ),
     );
     return [newRows, differingRowHashes];
@@ -2887,43 +2923,43 @@ const createMergeableStore = (uniqueId, getNow) => {
     return cellHashes;
   };
   const getMergeableCellDiff = (otherTableRowCellHashes) => {
-    const [[tableStampMaps, tablesTime]] = contentStampMap;
+    const [[tableStampMaps, tablesHlc]] = contentStampMap;
     const tablesObj = {};
     objForEach(otherTableRowCellHashes, (otherRowCellHashes, tableId) =>
       objForEach(otherRowCellHashes, (otherCellHashes, rowId) =>
         ifNotUndefined(
           mapGet(tableStampMaps, tableId),
-          ([rowStampMaps, tableTime]) =>
+          ([rowStampMaps, tableHlc]) =>
             ifNotUndefined(
               mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime]) =>
-                mapForEach(cellStampMaps, (cellId, [cell, cellTime, hash]) =>
+              ([cellStampMaps, rowHlc]) =>
+                mapForEach(cellStampMaps, (cellId, [cell, cellHlc, hash]) =>
                   hash !== otherCellHashes[cellId]
                     ? (objEnsure(
                         objEnsure(tablesObj, tableId, () =>
-                          stampNewObj(tableTime),
+                          stampNewObj(tableHlc),
                         )[0],
                         rowId,
-                        () => stampNewObj(rowTime),
-                      )[0][cellId] = [cell, cellTime])
+                        () => stampNewObj(rowHlc),
+                      )[0][cellId] = [cell, cellHlc])
                     : 0,
                 ),
             ),
         ),
       ),
     );
-    return stampNew(tablesObj, tablesTime);
+    return stampNew(tablesObj, tablesHlc);
   };
   const getMergeableValueHashes = () =>
     mapToObj(contentStampMap[1][0], getStampHash);
   const getMergeableValueDiff = (otherValueHashes) => {
-    const [, [valueStampMaps, valuesTime]] = contentStampMap;
+    const [, [valueStampMaps, valuesHlc]] = contentStampMap;
     const values = mapToObj(
       valueStampMaps,
       stampClone,
       ([, , hash], valueId) => hash == otherValueHashes?.[valueId],
     );
-    return stampNew(values, valuesTime);
+    return stampNew(values, valuesHlc);
   };
   const setMergeableContent = (mergeableContent) =>
     disableListeningToRawStoreChanges(() =>
@@ -2945,20 +2981,20 @@ const createMergeableStore = (uniqueId, getNow) => {
   };
   const getTransactionMergeableChanges = (withHashes = false) => {
     const [
-      [tableStampMaps, tablesTime, tablesHash],
-      [valueStampMaps, valuesTime, valuesHash],
+      [tableStampMaps, tablesHlc, tablesHash],
+      [valueStampMaps, valuesHlc, valuesHash],
     ] = contentStampMap;
     const newStamp = withHashes ? stampNewWithHash : stampNew;
     const tablesObj = {};
     collForEach(touchedCells, (touchedTable, tableId) =>
       ifNotUndefined(
         mapGet(tableStampMaps, tableId),
-        ([rowStampMaps, tableTime, tableHash]) => {
+        ([rowStampMaps, tableHlc, tableHash]) => {
           const tableObj = {};
           collForEach(touchedTable, (touchedRow, rowId) =>
             ifNotUndefined(
               mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime, rowHash]) => {
+              ([cellStampMaps, rowHlc, rowHash]) => {
                 const rowObj = {};
                 collForEach(touchedRow, (cellId) => {
                   ifNotUndefined(
@@ -2967,11 +3003,11 @@ const createMergeableStore = (uniqueId, getNow) => {
                       (rowObj[cellId] = newStamp(cell, time, hash)),
                   );
                 });
-                tableObj[rowId] = newStamp(rowObj, rowTime, rowHash);
+                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
               },
             ),
           );
-          tablesObj[tableId] = newStamp(tableObj, tableTime, tableHash);
+          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
         },
       ),
     );
@@ -2984,8 +3020,8 @@ const createMergeableStore = (uniqueId, getNow) => {
       ),
     );
     return [
-      newStamp(tablesObj, tablesTime, tablesHash),
-      newStamp(valuesObj, valuesTime, valuesHash),
+      newStamp(tablesObj, tablesHlc, tablesHash),
+      newStamp(valuesObj, valuesHlc, valuesHash),
       1,
     ];
   };
@@ -4608,18 +4644,18 @@ const createDurableObjectStoragePersister = (
   const setPersisted = async (
     getContent,
     [
-      [tablesObj, tablesTime, tablesHash],
-      [valuesObj, valuesTime, valuesHash],
+      [tablesObj, tablesHlc, tablesHash],
+      [valuesObj, valuesHlc, valuesHash],
     ] = getContent(),
   ) => {
     const keysToSet = mapNew();
-    mapSet(keysToSet, constructKey(T), [0, tablesTime, tablesHash]);
-    objForEach(tablesObj, ([tableObj, tableTime, tableHash], tableId) => {
-      mapSet(keysToSet, constructKey(T, tableId), [0, tableTime, tableHash]);
-      objForEach(tableObj, ([rowObj, rowTime, rowHash], rowId) => {
+    mapSet(keysToSet, constructKey(T), [0, tablesHlc, tablesHash]);
+    objForEach(tablesObj, ([tableObj, tableHlc, tableHash], tableId) => {
+      mapSet(keysToSet, constructKey(T, tableId), [0, tableHlc, tableHash]);
+      objForEach(tableObj, ([rowObj, rowHlc, rowHash], rowId) => {
         mapSet(keysToSet, constructKey(T, tableId, rowId), [
           0,
-          rowTime,
+          rowHlc,
           rowHash,
         ]);
         objForEach(rowObj, (cellStamp, cellId) =>
@@ -4627,7 +4663,7 @@ const createDurableObjectStoragePersister = (
         );
       });
     });
-    mapSet(keysToSet, constructKey(V), [0, valuesTime, valuesHash]);
+    mapSet(keysToSet, constructKey(V), [0, valuesHlc, valuesHash]);
     objForEach(valuesObj, (valueStamp, valueId) =>
       mapSet(keysToSet, constructKey(V, valueId), valueStamp),
     );
@@ -6335,11 +6371,11 @@ const createCustomSynchronizer = (
           ([cell2, cellTime2], cellId) =>
             (rowStamp[0][cellId] = stampNew(cell2, cellTime2)),
         );
-        rowStamp[1] = getLatestTime(rowStamp[1], rowTime2);
+        rowStamp[1] = getLatestHlc(rowStamp[1], rowTime2);
       });
-      tableStamp[1] = getLatestTime(tableStamp[1], tableTime2);
+      tableStamp[1] = getLatestHlc(tableStamp[1], tableTime2);
     });
-    tablesStamp[1] = getLatestTime(tablesStamp[1], tablesTime2);
+    tablesStamp[1] = getLatestHlc(tablesStamp[1], tablesTime2);
   };
   const getChangesFromOtherStore = (
     otherClientId = null,
@@ -10364,6 +10400,7 @@ const Inspector = ({position = 'right', open = false}) => {
 };
 
 export {
+  addOrRemoveHash,
   BackwardCheckpointsView,
   broadcastChanges,
   CellView,
@@ -10408,9 +10445,19 @@ export {
   EditableCellView,
   EditableValueView,
   ForwardCheckpointsView,
+  getCellHash,
+  getCellInRowHash,
+  getHash,
   getHlcFunctions,
-  getRandomValues,
+  getRowHash,
+  getRowInTableHash,
+  getTableHash,
+  getTableInTablesHash,
+  getTablesHash,
   getUniqueId$1 as getUniqueId,
+  getValueHash,
+  getValueInValuesHash,
+  getValuesHash,
   getWsServerDurableObjectFetch,
   hasStoreInStorage,
   IndexView$1 as IndexView,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinybase",
-  "version": "6.2.0-beta.3",
+  "version": "6.2.0",
   "author": "jamesgpearce",
   "repository": "github:tinyplex/tinybase",
   "license": "MIT",
@@ -22,9 +22,9 @@
   "sideEffects": false,
   "peerDependencies": {
     "@automerge/automerge-repo": "^1.2.1",
-    "@cloudflare/workers-types": "^4.20250529.0",
+    "@cloudflare/workers-types": "^4.20250531.0",
     "@electric-sql/pglite": "^0.2.17",
-    "@libsql/client": "^0.15.7",
+    "@libsql/client": "^0.15.8",
     "@powersync/common": "^1.31.0",
     "@sqlite.org/sqlite-wasm": "^3.49.2-build1",
     "@vlcn.io/crsqlite-wasm": "^0.16.0",

package/persisters/index.js

@@ -468,10 +468,17 @@ const createCustomPersister = (
   return objFreeze(persister);
 };
 
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithUndefined = (obj) =>
+  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+const jsonParseWithUndefined = (str) =>
+  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
+
 const textEncoder = /* @__PURE__ */ new GLOBAL.TextEncoder();
-const getHash = (value) => {
+const getHash = (string) => {
   let hash = 2166136261;
-  arrayForEach(textEncoder.encode(value), (char) => {
+  arrayForEach(textEncoder.encode(string), (char) => {
     hash ^= char;
     hash +=
       (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
@@ -479,13 +486,6 @@ const getHash = (value) => {
   return hash >>> 0;
 };
 
-const jsonString = JSON.stringify;
-const jsonParse = JSON.parse;
-const jsonStringWithUndefined = (obj) =>
-  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
-const jsonParseWithUndefined = (str) =>
-  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
-
 const SINGLE_ROW_ID = '_';
 const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
 const SELECT = 'SELECT';

package/persisters/persister-durable-object-storage/index.js

@@ -113,10 +113,10 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-const stampNewWithHash = (value, time, hash) => [value, time, hash];
-const stampUpdate = (stamp, time, hash) => {
-  if (time > stamp[1]) {
-    stamp[1] = time;
+const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
+const stampUpdate = (stamp, hlc, hash) => {
+  if (hlc > stamp[1]) {
+    stamp[1] = hlc;
   }
   stamp[2] = hash >>> 0;
 };
@@ -523,18 +523,18 @@ const createDurableObjectStoragePersister = (
   const setPersisted = async (
     getContent,
     [
-      [tablesObj, tablesTime, tablesHash],
-      [valuesObj, valuesTime, valuesHash],
+      [tablesObj, tablesHlc, tablesHash],
+      [valuesObj, valuesHlc, valuesHash],
     ] = getContent(),
   ) => {
     const keysToSet = mapNew();
-    mapSet(keysToSet, constructKey(T), [0, tablesTime, tablesHash]);
-    objForEach(tablesObj, ([tableObj, tableTime, tableHash], tableId) => {
-      mapSet(keysToSet, constructKey(T, tableId), [0, tableTime, tableHash]);
-      objForEach(tableObj, ([rowObj, rowTime, rowHash], rowId) => {
+    mapSet(keysToSet, constructKey(T), [0, tablesHlc, tablesHash]);
+    objForEach(tablesObj, ([tableObj, tableHlc, tableHash], tableId) => {
+      mapSet(keysToSet, constructKey(T, tableId), [0, tableHlc, tableHash]);
+      objForEach(tableObj, ([rowObj, rowHlc, rowHash], rowId) => {
         mapSet(keysToSet, constructKey(T, tableId, rowId), [
           0,
-          rowTime,
+          rowHlc,
           rowHash,
         ]);
         objForEach(rowObj, (cellStamp, cellId) =>
@@ -542,7 +542,7 @@ const createDurableObjectStoragePersister = (
         );
       });
     });
-    mapSet(keysToSet, constructKey(V), [0, valuesTime, valuesHash]);
+    mapSet(keysToSet, constructKey(V), [0, valuesHlc, valuesHash]);
     objForEach(valuesObj, (valueStamp, valueId) =>
       mapSet(keysToSet, constructKey(V, valueId), valueStamp),
     );

package/persisters/persister-durable-object-storage/with-schemas/index.js

@@ -113,10 +113,10 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-const stampNewWithHash = (value, time, hash) => [value, time, hash];
-const stampUpdate = (stamp, time, hash) => {
-  if (time > stamp[1]) {
-    stamp[1] = time;
+const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
+const stampUpdate = (stamp, hlc, hash) => {
+  if (hlc > stamp[1]) {
+    stamp[1] = hlc;
   }
   stamp[2] = hash >>> 0;
 };
@@ -523,18 +523,18 @@ const createDurableObjectStoragePersister = (
   const setPersisted = async (
     getContent,
     [
-      [tablesObj, tablesTime, tablesHash],
-      [valuesObj, valuesTime, valuesHash],
+      [tablesObj, tablesHlc, tablesHash],
+      [valuesObj, valuesHlc, valuesHash],
     ] = getContent(),
   ) => {
     const keysToSet = mapNew();
-    mapSet(keysToSet, constructKey(T), [0, tablesTime, tablesHash]);
-    objForEach(tablesObj, ([tableObj, tableTime, tableHash], tableId) => {
-      mapSet(keysToSet, constructKey(T, tableId), [0, tableTime, tableHash]);
-      objForEach(tableObj, ([rowObj, rowTime, rowHash], rowId) => {
+    mapSet(keysToSet, constructKey(T), [0, tablesHlc, tablesHash]);
+    objForEach(tablesObj, ([tableObj, tableHlc, tableHash], tableId) => {
+      mapSet(keysToSet, constructKey(T, tableId), [0, tableHlc, tableHash]);
+      objForEach(tableObj, ([rowObj, rowHlc, rowHash], rowId) => {
         mapSet(keysToSet, constructKey(T, tableId, rowId), [
           0,
-          rowTime,
+          rowHlc,
           rowHash,
         ]);
         objForEach(rowObj, (cellStamp, cellId) =>
@@ -542,7 +542,7 @@ const createDurableObjectStoragePersister = (
         );
       });
     });
-    mapSet(keysToSet, constructKey(V), [0, valuesTime, valuesHash]);
+    mapSet(keysToSet, constructKey(V), [0, valuesHlc, valuesHash]);
     objForEach(valuesObj, (valueStamp, valueId) =>
       mapSet(keysToSet, constructKey(V, valueId), valueStamp),
     );