tinybase 6.0.0 → 6.1.0-beta.1

package/index.js

@@ -977,1118 +977,297 @@ const createIndexes = getCreateFunction((store) => {
   return objFreeze(indexes);
 });
 
-const numericAggregators = /* @__PURE__ */ mapNew([
-  [
-    AVG,
-    [
-      (numbers, length) => arraySum(numbers) / length,
-      (metric, add, length) => metric + (add - metric) / (length + 1),
-      (metric, remove, length) => metric + (metric - remove) / (length - 1),
-      (metric, add, remove, length) => metric + (add - remove) / length,
-    ],
-  ],
-  [
-    MAX,
-    [
-      (numbers) => mathMax(...numbers),
-      (metric, add) => mathMax(add, metric),
-      (metric, remove) => (remove == metric ? void 0 : metric),
-      (metric, add, remove) =>
-        remove == metric ? void 0 : mathMax(add, metric),
-    ],
-  ],
-  [
-    MIN,
-    [
-      (numbers) => mathMin(...numbers),
-      (metric, add) => mathMin(add, metric),
-      (metric, remove) => (remove == metric ? void 0 : metric),
-      (metric, add, remove) =>
-        remove == metric ? void 0 : mathMin(add, metric),
-    ],
-  ],
-  [
-    SUM,
-    [
-      (numbers) => arraySum(numbers),
-      (metric, add) => metric + add,
-      (metric, remove) => metric - remove,
-      (metric, add, remove) => metric - remove + add,
-    ],
-  ],
-]);
-const getAggregateValue = (
-  aggregateValue,
-  oldLength,
-  newValues,
-  changedValues,
-  aggregators,
-  force = false,
-) => {
-  if (collIsEmpty(newValues)) {
-    return void 0;
-  }
-  const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =
-    aggregators;
-  force ||= isUndefined(aggregateValue);
-  collForEach(changedValues, ([oldValue, newValue]) => {
-    if (!force) {
-      aggregateValue = isUndefined(oldValue)
-        ? aggregateAdd?.(aggregateValue, newValue, oldLength++)
-        : isUndefined(newValue)
-          ? aggregateRemove?.(aggregateValue, oldValue, oldLength--)
-          : aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);
-      force ||= isUndefined(aggregateValue);
-    }
+const textEncoder = /* @__PURE__ */ new GLOBAL.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 force
-    ? aggregate(collValues(newValues), collSize(newValues))
-    : aggregateValue;
+  return hash >>> 0;
 };
 
-const createMetrics = getCreateFunction((store) => {
-  const metricListeners = mapNew();
-  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
-    () => metrics,
-  );
-  const [
-    getStore,
-    getMetricIds,
-    forEachMetric,
-    hasMetric,
-    getTableId,
-    getMetric,
-    setMetric,
-    ,
-    setDefinitionAndListen,
-    delDefinition,
-    addMetricIdsListener,
-    destroy,
-  ] = getDefinableFunctions(
-    store,
-    getUndefined,
-    (value) =>
-      isNaN(value) ||
-      isUndefined(value) ||
-      value === true ||
-      value === false ||
-      value === EMPTY_STRING
-        ? void 0
-        : value * 1,
-    addListener,
-    callListeners,
+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 encodeTimeAndCounter = (logicalTime42, counter24) =>
+  encode(logicalTime42 / SHIFT36) +
+  encode(logicalTime42 / SHIFT30) +
+  encode(logicalTime42 / SHIFT24) +
+  encode(logicalTime42 / SHIFT18) +
+  encode(logicalTime42 / SHIFT12) +
+  encode(logicalTime42 / SHIFT6) +
+  encode(logicalTime42) +
+  encode(counter24 / SHIFT18) +
+  encode(counter24 / SHIFT12) +
+  encode(counter24 / SHIFT6) +
+  encode(counter24);
+const decodeTimeAndCounter = (hlc16) => [
+  decode(hlc16, 0) * SHIFT36 +
+    decode(hlc16, 1) * SHIFT30 +
+    decode(hlc16, 2) * SHIFT24 +
+    decode(hlc16, 3) * SHIFT18 +
+    decode(hlc16, 4) * SHIFT12 +
+    decode(hlc16, 5) * SHIFT6 +
+    decode(hlc16, 6),
+  decode(hlc16, 7) * SHIFT18 +
+    decode(hlc16, 8) * SHIFT12 +
+    decode(hlc16, 9) * SHIFT6 +
+    decode(hlc16, 10),
+];
+const getHlcFunctions = (uniqueId) => {
+  let logicalTime = 0;
+  let lastCounter = -1;
+  const clientPart = ifNotUndefined(
+    uniqueId,
+    (uniqueId2) => {
+      const clientHash30 = getHash(uniqueId2);
+      return (
+        encode(clientHash30 / SHIFT24) +
+        encode(clientHash30 / SHIFT18) +
+        encode(clientHash30 / SHIFT12) +
+        encode(clientHash30 / SHIFT6) +
+        encode(clientHash30)
+      );
+    },
+    () => getUniqueId(5),
   );
-  const setMetricDefinition = (
-    metricId,
-    tableId,
-    aggregate,
-    getNumber,
-    aggregateAdd,
-    aggregateRemove,
-    aggregateReplace,
-  ) => {
-    const aggregators = isFunction(aggregate)
-      ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
-      : (mapGet(numericAggregators, aggregate) ??
-        mapGet(numericAggregators, SUM));
-    setDefinitionAndListen(
-      metricId,
-      tableId,
-      (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
-        const oldMetric = getMetric(metricId);
-        const oldLength = collSize(numbers);
-        force ||= isUndefined(oldMetric);
-        change();
-        let newMetric = getAggregateValue(
-          oldMetric,
-          oldLength,
-          numbers,
-          changedNumbers,
-          aggregators,
-          force,
-        );
-        if (!isFiniteNumber(newMetric)) {
-          newMetric = void 0;
-        }
-        if (newMetric != oldMetric) {
-          setMetric(metricId, newMetric);
-          callListeners(metricListeners, [metricId], newMetric, oldMetric);
-        }
-      },
-      getRowCellFunction(getNumber, 1),
-    );
-    return metrics;
-  };
-  const delMetricDefinition = (metricId) => {
-    delDefinition(metricId);
-    return metrics;
-  };
-  const addMetricListener = (metricId, listener) =>
-    addListener(listener, metricListeners, [metricId]);
-  const delListener = (listenerId) => {
-    delListenerImpl(listenerId);
-    return metrics;
+  const getHlc = () => {
+    seenHlc();
+    return encodeTimeAndCounter(logicalTime, ++lastCounter) + clientPart;
   };
-  const getListenerStats = () => ({
-    metric: collSize2(metricListeners),
-  });
-  const metrics = {
-    setMetricDefinition,
-    delMetricDefinition,
-    getStore,
-    getMetricIds,
-    forEachMetric,
-    hasMetric,
-    getTableId,
-    getMetric,
-    addMetricIdsListener,
-    addMetricListener,
-    delListener,
-    destroy,
-    getListenerStats,
+  const seenHlc = (hlc) => {
+    const previousLogicalTime = logicalTime;
+    const [remoteLogicalTime, remoteCounter] =
+      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeTimeAndCounter(hlc);
+    logicalTime = mathMax(
+      previousLogicalTime,
+      remoteLogicalTime,
+      GLOBAL.HLC_TIME ?? Date.now(),
+    );
+    lastCounter =
+      logicalTime == previousLogicalTime
+        ? logicalTime == remoteLogicalTime
+          ? mathMax(lastCounter, remoteCounter)
+          : lastCounter
+        : logicalTime == remoteLogicalTime
+          ? remoteCounter
+          : -1;
   };
-  return objFreeze(metrics);
-});
+  return [getHlc, seenHlc];
+};
 
-const createQueries = getCreateFunction((store) => {
-  const createStore = store.createStore;
-  const preStore = createStore();
-  const resultStore = createStore();
-  const preStoreListenerIds = mapNew();
-  const {
-    addListener,
-    callListeners,
-    delListener: delListenerImpl,
-  } = resultStore;
-  const [
-    getStore,
-    getQueryIds,
-    forEachQuery,
-    hasQuery,
-    getTableId,
-    ,
-    ,
-    setDefinition,
-    ,
-    delDefinition,
-    addQueryIdsListenerImpl,
-    destroy,
-    addStoreListeners,
-    delStoreListeners,
-  ] = getDefinableFunctions(
-    store,
-    () => true,
-    getUndefined,
-    addListener,
-    callListeners,
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithMap = (obj) =>
+  jsonString(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
   );
-  const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
-    arrayForEach(listenerIds, (listenerId) =>
-      setAdd(
-        mapEnsure(
-          mapEnsure(preStoreListenerIds, queryId, mapNew),
-          preStore2,
-          setNew,
+
+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 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) =>
+  /* istanbul ignore next */
+  ((time1 ?? '') > (time2 ?? '') ? time1 : time2) ?? '';
+const stampUpdate = (stamp, time, hash) => {
+  if (time > stamp[1]) {
+    stamp[1] = time;
+  }
+  stamp[2] = hash >>> 0;
+};
+const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
+const stampNewMap = (time = EMPTY_STRING) => [mapNew(), time, 0];
+const stampMapToObjWithHash = (
+  [map, time, hash],
+  mapper = stampCloneWithHash,
+) => [mapToObj(map, mapper), time, hash];
+const stampMapToObjWithoutHash = ([map, time], mapper = stampClone) =>
+  stampNew(mapToObj(map, mapper), time);
+const stampValidate = (stamp, validateThing) =>
+  isArray(stamp) &&
+  size(stamp) == 3 &&
+  isString(stamp[1]) &&
+  getTypeOf(stamp[2]) == NUMBER &&
+  isFiniteNumber(stamp[2]) &&
+  validateThing(stamp[0]);
+
+const pairNew = (value) => [value, value];
+const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
+const pairNewMap = () => [mapNew(), mapNew()];
+const pairClone = (array) => [...array];
+const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
+
+const idsChanged = (changedIds, id2, addedOrRemoved) =>
+  mapSet(
+    changedIds,
+    id2,
+    mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
+  );
+const createStore = () => {
+  let hasTablesSchema;
+  let hasValuesSchema;
+  let hadTables = false;
+  let hadValues = false;
+  let transactions = 0;
+  let internalListeners = [];
+  const changedTableIds = mapNew();
+  const changedTableCellIds = mapNew();
+  const changedRowCount = mapNew();
+  const changedRowIds = mapNew();
+  const changedCellIds = mapNew();
+  const changedCells = mapNew();
+  const changedValueIds = mapNew();
+  const changedValues = mapNew();
+  const invalidCells = mapNew();
+  const invalidValues = mapNew();
+  const tablesSchemaMap = mapNew();
+  const tablesSchemaRowCache = mapNew();
+  const valuesSchemaMap = mapNew();
+  const valuesDefaulted = mapNew();
+  const valuesNonDefaulted = setNew();
+  const tablePoolFunctions = mapNew();
+  const tableCellIds = mapNew();
+  const tablesMap = mapNew();
+  const valuesMap = mapNew();
+  const hasTablesListeners = pairNewMap();
+  const tablesListeners = pairNewMap();
+  const tableIdsListeners = pairNewMap();
+  const hasTableListeners = pairNewMap();
+  const tableListeners = pairNewMap();
+  const tableCellIdsListeners = pairNewMap();
+  const hasTableCellListeners = pairNewMap();
+  const rowCountListeners = pairNewMap();
+  const rowIdsListeners = pairNewMap();
+  const sortedRowIdsListeners = pairNewMap();
+  const hasRowListeners = pairNewMap();
+  const rowListeners = pairNewMap();
+  const cellIdsListeners = pairNewMap();
+  const hasCellListeners = pairNewMap();
+  const cellListeners = pairNewMap();
+  const invalidCellListeners = pairNewMap();
+  const invalidValueListeners = pairNewMap();
+  const hasValuesListeners = pairNewMap();
+  const valuesListeners = pairNewMap();
+  const valueIdsListeners = pairNewMap();
+  const hasValueListeners = pairNewMap();
+  const valueListeners = pairNewMap();
+  const startTransactionListeners = mapNew();
+  const finishTransactionListeners = pairNewMap();
+  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
+    getListenerFunctions(() => store);
+  const validateTablesSchema = (tableSchema) =>
+    objValidate(tableSchema, (tableSchema2) =>
+      objValidate(tableSchema2, validateCellOrValueSchema),
+    );
+  const validateValuesSchema = (valuesSchema) =>
+    objValidate(valuesSchema, validateCellOrValueSchema);
+  const validateCellOrValueSchema = (schema) => {
+    if (!objValidate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
+      return false;
+    }
+    const type = schema[TYPE];
+    if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+      return false;
+    }
+    if (getCellOrValueType(schema[DEFAULT]) != type) {
+      objDel(schema, DEFAULT);
+    }
+    return true;
+  };
+  const validateContent = isArray;
+  const validateTables = (tables) =>
+    objValidate(tables, validateTable, cellInvalid);
+  const validateTable = (table, tableId) =>
+    (!hasTablesSchema ||
+      collHas(tablesSchemaMap, tableId) ||
+      /* istanbul ignore next */
+      cellInvalid(tableId)) &&
+    objValidate(
+      table,
+      (row, rowId) => validateRow(tableId, rowId, row),
+      () => cellInvalid(tableId),
+    );
+  const validateRow = (tableId, rowId, row, skipDefaults) =>
+    objValidate(
+      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
+      (cell, cellId) =>
+        ifNotUndefined(
+          getValidatedCell(tableId, rowId, cellId, cell),
+          (validCell) => {
+            row[cellId] = validCell;
+            return true;
+          },
+          () => false,
         ),
-        listenerId,
-      ),
+      () => cellInvalid(tableId, rowId),
     );
-  const resetPreStores = (queryId) => {
+  const getValidatedCell = (tableId, rowId, cellId, cell) =>
+    hasTablesSchema
+      ? ifNotUndefined(
+          mapGet(mapGet(tablesSchemaMap, tableId), cellId),
+          (cellSchema) =>
+            getCellOrValueType(cell) != cellSchema[TYPE]
+              ? cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
+              : cell,
+          () => cellInvalid(tableId, rowId, cellId, cell),
+        )
+      : isUndefined(getCellOrValueType(cell))
+        ? cellInvalid(tableId, rowId, cellId, cell)
+        : cell;
+  const validateValues = (values, skipDefaults) =>
+    objValidate(
+      skipDefaults ? values : addDefaultsToValues(values),
+      (value, valueId) =>
+        ifNotUndefined(
+          getValidatedValue(valueId, value),
+          (validValue) => {
+            values[valueId] = validValue;
+            return true;
+          },
+          () => false,
+        ),
+      () => valueInvalid(),
+    );
+  const getValidatedValue = (valueId, value) =>
+    hasValuesSchema
+      ? ifNotUndefined(
+          mapGet(valuesSchemaMap, valueId),
+          (valueSchema) =>
+            getCellOrValueType(value) != valueSchema[TYPE]
+              ? valueInvalid(valueId, value, valueSchema[DEFAULT])
+              : value,
+          () => valueInvalid(valueId, value),
+        )
+      : isUndefined(getCellOrValueType(value))
+        ? valueInvalid(valueId, value)
+        : value;
+  const addDefaultsToRow = (row, tableId, rowId) => {
     ifNotUndefined(
-      mapGet(preStoreListenerIds, queryId),
-      (queryPreStoreListenerIds) => {
-        mapForEach(queryPreStoreListenerIds, (preStore2, listenerIds) =>
-          collForEach(listenerIds, (listenerId) =>
-            preStore2.delListener(listenerId),
-          ),
-        );
-        collClear(queryPreStoreListenerIds);
+      mapGet(tablesSchemaRowCache, tableId),
+      ([rowDefaulted, rowNonDefaulted]) => {
+        collForEach(rowDefaulted, (cell, cellId) => {
+          if (!objHas(row, cellId)) {
+            row[cellId] = cell;
+          }
+        });
+        collForEach(rowNonDefaulted, (cellId) => {
+          if (!objHas(row, cellId)) {
+            cellInvalid(tableId, rowId, cellId);
+          }
+        });
       },
     );
-    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
-  };
-  const synchronizeTransactions = (queryId, fromStore, toStore) =>
-    addPreStoreListener(
-      fromStore,
-      queryId,
-      fromStore.addStartTransactionListener(toStore.startTransaction),
-      fromStore.addDidFinishTransactionListener(() =>
-        toStore.finishTransaction(),
-      ),
-    );
-  const setQueryDefinition = (queryId, tableId, build) => {
-    setDefinition(queryId, tableId);
-    resetPreStores(queryId);
-    const selectEntries = [];
-    const joinEntries = [[null, [tableId, null, null, [], mapNew()]]];
-    const wheres = [];
-    const groupEntries = [];
-    const havings = [];
-    const select = (arg1, arg2) => {
-      const selectEntry = isFunction(arg1)
-        ? [size(selectEntries) + EMPTY_STRING, arg1]
-        : [
-            isUndefined(arg2) ? arg1 : arg2,
-            (getTableCell) => getTableCell(arg1, arg2),
-          ];
-      arrayPush(selectEntries, selectEntry);
-      return {as: (selectedCellId) => (selectEntry[0] = selectedCellId)};
-    };
-    const join = (joinedTableId, arg1, arg2) => {
-      const fromIntermediateJoinedTableId =
-        isUndefined(arg2) || isFunction(arg1) ? null : arg1;
-      const onArg = isUndefined(fromIntermediateJoinedTableId) ? arg1 : arg2;
-      const joinEntry = [
-        joinedTableId,
-        [
-          joinedTableId,
-          fromIntermediateJoinedTableId,
-          isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
-          [],
-          mapNew(),
-        ],
-      ];
-      arrayPush(joinEntries, joinEntry);
-      return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};
-    };
-    const where = (arg1, arg2, arg3) =>
-      arrayPush(
-        wheres,
-        isFunction(arg1)
-          ? arg1
-          : isUndefined(arg3)
-            ? (getTableCell) => getTableCell(arg1) === arg2
-            : (getTableCell) => getTableCell(arg1, arg2) === arg3,
-      );
-    const group = (
-      selectedCellId,
-      aggregate,
-      aggregateAdd,
-      aggregateRemove,
-      aggregateReplace,
-    ) => {
-      const groupEntry = [
-        selectedCellId,
-        [
-          selectedCellId,
-          isFunction(aggregate)
-            ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
-            : (mapGet(numericAggregators, aggregate) ?? [
-                (_cells, length) => length,
-              ]),
-        ],
-      ];
-      arrayPush(groupEntries, groupEntry);
-      return {as: (groupedCellId) => (groupEntry[0] = groupedCellId)};
-    };
-    const having = (arg1, arg2) =>
-      arrayPush(
-        havings,
-        isFunction(arg1)
-          ? arg1
-          : (getSelectedOrGroupedCell) =>
-              getSelectedOrGroupedCell(arg1) === arg2,
-      );
-    build({select, join, where, group, having});
-    const selects = mapNew(selectEntries);
-    if (collIsEmpty(selects)) {
-      return queries;
-    }
-    const joins = mapNew(joinEntries);
-    mapForEach(joins, (asTableId, [, fromAsTableId]) =>
-      ifNotUndefined(mapGet(joins, fromAsTableId), ({3: toAsTableIds}) =>
-        isUndefined(asTableId) ? 0 : arrayPush(toAsTableIds, asTableId),
-      ),
-    );
-    const groups = mapNew(groupEntries);
-    let selectJoinWhereStore = preStore;
-    if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
-      selectJoinWhereStore = resultStore;
-    } else {
-      synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);
-      const groupedSelectedCellIds = mapNew();
-      mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
-        setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
-          groupedCellId,
-          aggregators,
-        ]),
-      );
-      const groupBySelectedCellIds = setNew();
-      mapForEach(selects, (selectedCellId) =>
-        collHas(groupedSelectedCellIds, selectedCellId)
-          ? 0
-          : setAdd(groupBySelectedCellIds, selectedCellId),
-      );
-      const tree = mapNew();
-      const writeGroupRow = (
-        leaf,
-        changedGroupedSelectedCells,
-        selectedRowId,
-        forceRemove,
-      ) =>
-        ifNotUndefined(
-          leaf,
-          ([selectedCells, selectedRowIds, groupRowId, groupRow]) => {
-            mapForEach(
-              changedGroupedSelectedCells,
-              (selectedCellId, [newCell]) => {
-                const selectedCell = mapEnsure(
-                  selectedCells,
-                  selectedCellId,
-                  mapNew,
-                );
-                const oldLeafCell = mapGet(selectedCell, selectedRowId);
-                const newLeafCell = forceRemove ? void 0 : newCell;
-                if (oldLeafCell !== newLeafCell) {
-                  const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);
-                  const oldLength = collSize(selectedCell);
-                  mapSet(selectedCell, selectedRowId, newLeafCell);
-                  collForEach(
-                    mapGet(groupedSelectedCellIds, selectedCellId),
-                    ([groupedCellId, aggregators]) => {
-                      const aggregateValue = getAggregateValue(
-                        groupRow[groupedCellId],
-                        oldLength,
-                        selectedCell,
-                        oldNewSet,
-                        aggregators,
-                      );
-                      groupRow[groupedCellId] = isUndefined(
-                        getCellOrValueType(aggregateValue),
-                      )
-                        ? null
-                        : aggregateValue;
-                    },
-                  );
-                }
-              },
-            );
-            if (
-              collIsEmpty(selectedRowIds) ||
-              !arrayEvery(havings, (having2) =>
-                having2((cellId) => groupRow[cellId]),
-              )
-            ) {
-              resultStore.delRow(queryId, groupRowId);
-            } else if (isUndefined(groupRowId)) {
-              leaf[2] = resultStore.addRow(queryId, groupRow);
-            } else {
-              resultStore.setRow(queryId, groupRowId, groupRow);
-            }
-          },
-        );
-      addPreStoreListener(
-        selectJoinWhereStore,
-        queryId,
-        selectJoinWhereStore.addRowListener(
-          queryId,
-          null,
-          (_store, _tableId, selectedRowId, getCellChange) => {
-            const oldPath = [];
-            const newPath = [];
-            const changedGroupedSelectedCells = mapNew();
-            const rowExists = selectJoinWhereStore.hasRow(
-              queryId,
-              selectedRowId,
-            );
-            let changedLeaf = !rowExists;
-            collForEach(groupBySelectedCellIds, (selectedCellId) => {
-              const [changed, oldCell, newCell] = getCellChange(
-                queryId,
-                selectedRowId,
-                selectedCellId,
-              );
-              arrayPush(oldPath, oldCell);
-              arrayPush(newPath, newCell);
-              changedLeaf ||= changed;
-            });
-            mapForEach(groupedSelectedCellIds, (selectedCellId) => {
-              const [changed, , newCell] = getCellChange(
-                queryId,
-                selectedRowId,
-                selectedCellId,
-              );
-              if (changedLeaf || changed) {
-                mapSet(changedGroupedSelectedCells, selectedCellId, [newCell]);
-              }
-            });
-            if (changedLeaf) {
-              writeGroupRow(
-                visitTree(tree, oldPath, void 0, ([, selectedRowIds]) => {
-                  collDel(selectedRowIds, selectedRowId);
-                  return collIsEmpty(selectedRowIds);
-                }),
-                changedGroupedSelectedCells,
-                selectedRowId,
-                1,
-              );
-            }
-            if (rowExists) {
-              writeGroupRow(
-                visitTree(
-                  tree,
-                  newPath,
-                  () => {
-                    const groupRow = {};
-                    collForEach(
-                      groupBySelectedCellIds,
-                      (selectedCellId) =>
-                        (groupRow[selectedCellId] =
-                          selectJoinWhereStore.getCell(
-                            queryId,
-                            selectedRowId,
-                            selectedCellId,
-                          )),
-                    );
-                    return [mapNew(), setNew(), void 0, groupRow];
-                  },
-                  ([, selectedRowIds]) => {
-                    setAdd(selectedRowIds, selectedRowId);
-                  },
-                ),
-                changedGroupedSelectedCells,
-                selectedRowId,
-              );
-            }
-          },
-        ),
-      );
-    }
-    synchronizeTransactions(queryId, store, selectJoinWhereStore);
-    const writeSelectRow = (rootRowId) => {
-      const getTableCell = (arg1, arg2) =>
-        store.getCell(
-          ...(isUndefined(arg2)
-            ? [tableId, rootRowId, arg1]
-            : arg1 === tableId
-              ? [tableId, rootRowId, arg2]
-              : [
-                  mapGet(joins, arg1)?.[0],
-                  mapGet(mapGet(joins, arg1)?.[4], rootRowId)?.[0],
-                  arg2,
-                ]),
-        );
-      selectJoinWhereStore.transaction(() =>
-        arrayEvery(wheres, (where2) => where2(getTableCell))
-          ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              setOrDelCell(
-                selectJoinWhereStore,
-                queryId,
-                rootRowId,
-                asCellId,
-                tableCellGetter(getTableCell, rootRowId),
-              ),
-            )
-          : selectJoinWhereStore.delRow(queryId, rootRowId),
-      );
-    };
-    const listenToTable = (rootRowId, tableId2, rowId, joinedTableIds2) => {
-      const getCell = (cellId) => store.getCell(tableId2, rowId, cellId);
-      arrayForEach(joinedTableIds2, (remoteAsTableId) => {
-        const [realJoinedTableId, , on, nextJoinedTableIds, remoteIdPair] =
-          mapGet(joins, remoteAsTableId);
-        const remoteRowId = on?.(getCell, rootRowId);
-        const [previousRemoteRowId, previousRemoteListenerId] =
-          mapGet(remoteIdPair, rootRowId) ?? [];
-        if (remoteRowId != previousRemoteRowId) {
-          if (!isUndefined(previousRemoteListenerId)) {
-            delStoreListeners(queryId, previousRemoteListenerId);
-          }
-          mapSet(
-            remoteIdPair,
-            rootRowId,
-            isUndefined(remoteRowId)
-              ? null
-              : [
-                  remoteRowId,
-                  ...addStoreListeners(
-                    queryId,
-                    1,
-                    store.addRowListener(realJoinedTableId, remoteRowId, () =>
-                      listenToTable(
-                        rootRowId,
-                        realJoinedTableId,
-                        remoteRowId,
-                        nextJoinedTableIds,
-                      ),
-                    ),
-                  ),
-                ],
-          );
-        }
-      });
-      writeSelectRow(rootRowId);
-    };
-    const {3: joinedTableIds} = mapGet(joins, null);
-    selectJoinWhereStore.transaction(() =>
-      addStoreListeners(
-        queryId,
-        1,
-        store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {
-          if (store.hasRow(tableId, rootRowId)) {
-            listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);
-          } else {
-            selectJoinWhereStore.delRow(queryId, rootRowId);
-            collForEach(joins, ({4: idsByRootRowId}) =>
-              ifNotUndefined(
-                mapGet(idsByRootRowId, rootRowId),
-                ([, listenerId]) => {
-                  delStoreListeners(queryId, listenerId);
-                  mapSet(idsByRootRowId, rootRowId);
-                },
-              ),
-            );
-          }
-        }),
-      ),
-    );
-    return queries;
-  };
-  const delQueryDefinition = (queryId) => {
-    resetPreStores(queryId);
-    delDefinition(queryId);
-    return queries;
-  };
-  const addQueryIdsListener = (listener) =>
-    addQueryIdsListenerImpl(() => listener(queries));
-  const delListener = (listenerId) => {
-    delListenerImpl(listenerId);
-    return queries;
-  };
-  const getListenerStats = () => {
-    const {
-      tables: _1,
-      tableIds: _2,
-      transaction: _3,
-      ...stats
-    } = resultStore.getListenerStats();
-    return stats;
-  };
-  const queries = {
-    setQueryDefinition,
-    delQueryDefinition,
-    getStore,
-    getQueryIds,
-    forEachQuery,
-    hasQuery,
-    getTableId,
-    addQueryIdsListener,
-    delListener,
-    destroy,
-    getListenerStats,
-  };
-  objMap(
-    {
-      [TABLE]: [1, 1],
-      [TABLE + CELL_IDS]: [0, 1],
-      [ROW_COUNT]: [0, 1],
-      [ROW_IDS]: [0, 1],
-      [SORTED_ROW_IDS]: [0, 5],
-      [ROW]: [1, 2],
-      [CELL_IDS]: [0, 2],
-      [CELL]: [1, 3],
-    },
-    ([hasAndForEach, argumentCount], gettable) => {
-      arrayForEach(
-        hasAndForEach ? [GET, 'has', 'forEach'] : [GET],
-        (prefix) =>
-          (queries[prefix + RESULT + gettable] = (...args) =>
-            resultStore[prefix + gettable](...args)),
-      );
-      queries[ADD + RESULT + gettable + LISTENER] = (...args) =>
-        resultStore[ADD + gettable + LISTENER](
-          ...slice(args, 0, argumentCount),
-          (_store, ...listenerArgs) =>
-            args[argumentCount](queries, ...listenerArgs),
-          true,
-        );
-    },
-  );
-  return objFreeze(queries);
-});
-
-const createRelationships = getCreateFunction((store) => {
-  const remoteTableIds = mapNew();
-  const remoteRowIdListeners = mapNew();
-  const localRowIdsListeners = mapNew();
-  const linkedRowIdsListeners = mapNew();
-  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
-    () => relationships,
-  );
-  const [
-    getStore,
-    getRelationshipIds,
-    forEachRelationshipImpl,
-    hasRelationship,
-    getLocalTableId,
-    getRelationship,
-    ,
-    ,
-    setDefinitionAndListen,
-    delDefinition,
-    addRelationshipIdsListener,
-    destroy,
-  ] = getDefinableFunctions(
-    store,
-    () => [mapNew(), mapNew(), mapNew(), mapNew()],
-    (value) => (isUndefined(value) ? void 0 : value + EMPTY_STRING),
-    addListener,
-    callListeners,
-  );
-  const getLinkedRowIdsCache = (relationshipId, firstRowId, skipCache) =>
-    ifNotUndefined(
-      getRelationship(relationshipId),
-      ([remoteRows, , linkedRowsCache]) => {
-        if (!collHas(linkedRowsCache, firstRowId)) {
-          const linkedRows = setNew();
-          if (
-            getLocalTableId(relationshipId) != getRemoteTableId(relationshipId)
-          ) {
-            setAdd(linkedRows, firstRowId);
-          } else {
-            let rowId = firstRowId;
-            while (!isUndefined(rowId) && !collHas(linkedRows, rowId)) {
-              setAdd(linkedRows, rowId);
-              rowId = mapGet(remoteRows, rowId);
-            }
-          }
-          if (skipCache) {
-            return linkedRows;
-          }
-          mapSet(linkedRowsCache, firstRowId, linkedRows);
-        }
-        return mapGet(linkedRowsCache, firstRowId);
-      },
-    );
-  const delLinkedRowIdsCache = (relationshipId, firstRowId) =>
-    ifNotUndefined(getRelationship(relationshipId), ([, , linkedRowsCache]) =>
-      mapSet(linkedRowsCache, firstRowId),
-    );
-  const setRelationshipDefinition = (
-    relationshipId,
-    localTableId,
-    remoteTableId,
-    getRemoteRowId2,
-  ) => {
-    mapSet(remoteTableIds, relationshipId, remoteTableId);
-    setDefinitionAndListen(
-      relationshipId,
-      localTableId,
-      (change, changedRemoteRowIds) => {
-        const changedLocalRows = setNew();
-        const changedRemoteRows = setNew();
-        const changedLinkedRows = setNew();
-        const [localRows, remoteRows] = getRelationship(relationshipId);
-        collForEach(
-          changedRemoteRowIds,
-          ([oldRemoteRowId, newRemoteRowId], localRowId) => {
-            if (!isUndefined(oldRemoteRowId)) {
-              setAdd(changedRemoteRows, oldRemoteRowId);
-              ifNotUndefined(
-                mapGet(remoteRows, oldRemoteRowId),
-                (oldRemoteRow) => {
-                  collDel(oldRemoteRow, localRowId);
-                  if (collIsEmpty(oldRemoteRow)) {
-                    mapSet(remoteRows, oldRemoteRowId);
-                  }
-                },
-              );
-            }
-            if (!isUndefined(newRemoteRowId)) {
-              setAdd(changedRemoteRows, newRemoteRowId);
-              if (!collHas(remoteRows, newRemoteRowId)) {
-                mapSet(remoteRows, newRemoteRowId, setNew());
-              }
-              setAdd(mapGet(remoteRows, newRemoteRowId), localRowId);
-            }
-            setAdd(changedLocalRows, localRowId);
-            mapSet(localRows, localRowId, newRemoteRowId);
-            mapForEach(
-              mapGet(linkedRowIdsListeners, relationshipId),
-              (firstRowId) => {
-                if (
-                  collHas(
-                    getLinkedRowIdsCache(relationshipId, firstRowId),
-                    localRowId,
-                  )
-                ) {
-                  setAdd(changedLinkedRows, firstRowId);
-                }
-              },
-            );
-          },
-        );
-        change();
-        collForEach(changedLocalRows, (localRowId) =>
-          callListeners(remoteRowIdListeners, [relationshipId, localRowId]),
-        );
-        collForEach(changedRemoteRows, (remoteRowId) =>
-          callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),
-        );
-        collForEach(changedLinkedRows, (firstRowId) => {
-          delLinkedRowIdsCache(relationshipId, firstRowId);
-          callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);
-        });
-      },
-      getRowCellFunction(getRemoteRowId2),
-    );
-    return relationships;
-  };
-  const forEachRelationship = (relationshipCallback) =>
-    forEachRelationshipImpl((relationshipId) =>
-      relationshipCallback(relationshipId, (rowCallback) =>
-        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
-      ),
-    );
-  const delRelationshipDefinition = (relationshipId) => {
-    mapSet(remoteTableIds, relationshipId);
-    delDefinition(relationshipId);
-    return relationships;
-  };
-  const getRemoteTableId = (relationshipId) =>
-    mapGet(remoteTableIds, relationshipId);
-  const getRemoteRowId = (relationshipId, localRowId) =>
-    mapGet(getRelationship(relationshipId)?.[0], localRowId);
-  const getLocalRowIds = (relationshipId, remoteRowId) =>
-    collValues(mapGet(getRelationship(relationshipId)?.[1], remoteRowId));
-  const getLinkedRowIds = (relationshipId, firstRowId) =>
-    isUndefined(getRelationship(relationshipId))
-      ? [firstRowId]
-      : collValues(getLinkedRowIdsCache(relationshipId, firstRowId, true));
-  const addRemoteRowIdListener = (relationshipId, localRowId, listener) =>
-    addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);
-  const addLocalRowIdsListener = (relationshipId, remoteRowId, listener) =>
-    addListener(listener, localRowIdsListeners, [relationshipId, remoteRowId]);
-  const addLinkedRowIdsListener = (relationshipId, firstRowId, listener) => {
-    getLinkedRowIdsCache(relationshipId, firstRowId);
-    return addListener(listener, linkedRowIdsListeners, [
-      relationshipId,
-      firstRowId,
-    ]);
-  };
-  const delListener = (listenerId) => {
-    delLinkedRowIdsCache(...(delListenerImpl(listenerId) ?? []));
-    return relationships;
-  };
-  const getListenerStats = () => ({
-    remoteRowId: collSize3(remoteRowIdListeners),
-    localRowIds: collSize3(localRowIdsListeners),
-    linkedRowIds: collSize3(linkedRowIdsListeners),
-  });
-  const relationships = {
-    setRelationshipDefinition,
-    delRelationshipDefinition,
-    getStore,
-    getRelationshipIds,
-    forEachRelationship,
-    hasRelationship,
-    getLocalTableId,
-    getRemoteTableId,
-    getRemoteRowId,
-    getLocalRowIds,
-    getLinkedRowIds,
-    addRelationshipIdsListener,
-    addRemoteRowIdListener,
-    addLocalRowIdsListener,
-    addLinkedRowIdsListener,
-    delListener,
-    destroy,
-    getListenerStats,
-  };
-  return objFreeze(relationships);
-});
-
-const textEncoder = /* @__PURE__ */ new GLOBAL.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 SHIFT36 = 2 ** 36;
-const SHIFT30 = 2 ** 30;
-const SHIFT24 = 2 ** 24;
-const SHIFT18 = 2 ** 18;
-const SHIFT12 = 2 ** 12;
-const SHIFT6 = 2 ** 6;
-const encodeTimeAndCounter = (logicalTime42, counter24) =>
-  encode(logicalTime42 / SHIFT36) +
-  encode(logicalTime42 / SHIFT30) +
-  encode(logicalTime42 / SHIFT24) +
-  encode(logicalTime42 / SHIFT18) +
-  encode(logicalTime42 / SHIFT12) +
-  encode(logicalTime42 / SHIFT6) +
-  encode(logicalTime42) +
-  encode(counter24 / SHIFT18) +
-  encode(counter24 / SHIFT12) +
-  encode(counter24 / SHIFT6) +
-  encode(counter24);
-const decodeTimeAndCounter = (hlc16) => [
-  decode(hlc16, 0) * SHIFT36 +
-    decode(hlc16, 1) * SHIFT30 +
-    decode(hlc16, 2) * SHIFT24 +
-    decode(hlc16, 3) * SHIFT18 +
-    decode(hlc16, 4) * SHIFT12 +
-    decode(hlc16, 5) * SHIFT6 +
-    decode(hlc16, 6),
-  decode(hlc16, 7) * SHIFT18 +
-    decode(hlc16, 8) * SHIFT12 +
-    decode(hlc16, 9) * SHIFT6 +
-    decode(hlc16, 10),
-];
-const getHlcFunctions = (uniqueId) => {
-  let logicalTime = 0;
-  let lastCounter = -1;
-  const clientPart = ifNotUndefined(
-    uniqueId,
-    (uniqueId2) => {
-      const clientHash30 = getHash(uniqueId2);
-      return (
-        encode(clientHash30 / SHIFT24) +
-        encode(clientHash30 / SHIFT18) +
-        encode(clientHash30 / SHIFT12) +
-        encode(clientHash30 / SHIFT6) +
-        encode(clientHash30)
-      );
-    },
-    () => getUniqueId(5),
-  );
-  const getHlc = () => {
-    seenHlc();
-    return encodeTimeAndCounter(logicalTime, ++lastCounter) + clientPart;
-  };
-  const seenHlc = (hlc) => {
-    const previousLogicalTime = logicalTime;
-    const [remoteLogicalTime, remoteCounter] =
-      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeTimeAndCounter(hlc);
-    logicalTime = mathMax(
-      previousLogicalTime,
-      remoteLogicalTime,
-      GLOBAL.HLC_TIME ?? Date.now(),
-    );
-    lastCounter =
-      logicalTime == previousLogicalTime
-        ? logicalTime == remoteLogicalTime
-          ? mathMax(lastCounter, remoteCounter)
-          : lastCounter
-        : logicalTime == remoteLogicalTime
-          ? remoteCounter
-          : -1;
-  };
-  return [getHlc, seenHlc];
-};
-
-const jsonString = JSON.stringify;
-const jsonParse = JSON.parse;
-const jsonStringWithMap = (obj) =>
-  jsonString(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : 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 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) =>
-  /* istanbul ignore next */
-  ((time1 ?? '') > (time2 ?? '') ? time1 : time2) ?? '';
-const stampUpdate = (stamp, time, hash) => {
-  if (time > stamp[1]) {
-    stamp[1] = time;
-  }
-  stamp[2] = hash >>> 0;
-};
-const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
-const stampNewMap = (time = EMPTY_STRING) => [mapNew(), time, 0];
-const stampMapToObjWithHash = (
-  [map, time, hash],
-  mapper = stampCloneWithHash,
-) => [mapToObj(map, mapper), time, hash];
-const stampMapToObjWithoutHash = ([map, time], mapper = stampClone) =>
-  stampNew(mapToObj(map, mapper), time);
-const stampValidate = (stamp, validateThing) =>
-  isArray(stamp) &&
-  size(stamp) == 3 &&
-  isString(stamp[1]) &&
-  getTypeOf(stamp[2]) == NUMBER &&
-  isFiniteNumber(stamp[2]) &&
-  validateThing(stamp[0]);
-
-const pairNew = (value) => [value, value];
-const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
-const pairNewMap = () => [mapNew(), mapNew()];
-const pairClone = (array) => [...array];
-const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
-
-const idsChanged = (changedIds, id2, addedOrRemoved) =>
-  mapSet(
-    changedIds,
-    id2,
-    mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
-  );
-const createStore = () => {
-  let hasTablesSchema;
-  let hasValuesSchema;
-  let hadTables = false;
-  let hadValues = false;
-  let transactions = 0;
-  let internalListeners = [];
-  const changedTableIds = mapNew();
-  const changedTableCellIds = mapNew();
-  const changedRowCount = mapNew();
-  const changedRowIds = mapNew();
-  const changedCellIds = mapNew();
-  const changedCells = mapNew();
-  const changedValueIds = mapNew();
-  const changedValues = mapNew();
-  const invalidCells = mapNew();
-  const invalidValues = mapNew();
-  const tablesSchemaMap = mapNew();
-  const tablesSchemaRowCache = mapNew();
-  const valuesSchemaMap = mapNew();
-  const valuesDefaulted = mapNew();
-  const valuesNonDefaulted = setNew();
-  const tablePoolFunctions = mapNew();
-  const tableCellIds = mapNew();
-  const tablesMap = mapNew();
-  const valuesMap = mapNew();
-  const hasTablesListeners = pairNewMap();
-  const tablesListeners = pairNewMap();
-  const tableIdsListeners = pairNewMap();
-  const hasTableListeners = pairNewMap();
-  const tableListeners = pairNewMap();
-  const tableCellIdsListeners = pairNewMap();
-  const hasTableCellListeners = pairNewMap();
-  const rowCountListeners = pairNewMap();
-  const rowIdsListeners = pairNewMap();
-  const sortedRowIdsListeners = pairNewMap();
-  const hasRowListeners = pairNewMap();
-  const rowListeners = pairNewMap();
-  const cellIdsListeners = pairNewMap();
-  const hasCellListeners = pairNewMap();
-  const cellListeners = pairNewMap();
-  const invalidCellListeners = pairNewMap();
-  const invalidValueListeners = pairNewMap();
-  const hasValuesListeners = pairNewMap();
-  const valuesListeners = pairNewMap();
-  const valueIdsListeners = pairNewMap();
-  const hasValueListeners = pairNewMap();
-  const valueListeners = pairNewMap();
-  const startTransactionListeners = mapNew();
-  const finishTransactionListeners = pairNewMap();
-  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
-    getListenerFunctions(() => store);
-  const validateTablesSchema = (tableSchema) =>
-    objValidate(tableSchema, (tableSchema2) =>
-      objValidate(tableSchema2, validateCellOrValueSchema),
-    );
-  const validateValuesSchema = (valuesSchema) =>
-    objValidate(valuesSchema, validateCellOrValueSchema);
-  const validateCellOrValueSchema = (schema) => {
-    if (!objValidate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
-      return false;
-    }
-    const type = schema[TYPE];
-    if (!isTypeStringOrBoolean(type) && type != NUMBER) {
-      return false;
-    }
-    if (getCellOrValueType(schema[DEFAULT]) != type) {
-      objDel(schema, DEFAULT);
-    }
-    return true;
-  };
-  const validateContent = isArray;
-  const validateTables = (tables) =>
-    objValidate(tables, validateTable, cellInvalid);
-  const validateTable = (table, tableId) =>
-    (!hasTablesSchema ||
-      collHas(tablesSchemaMap, tableId) ||
-      /* istanbul ignore next */
-      cellInvalid(tableId)) &&
-    objValidate(
-      table,
-      (row, rowId) => validateRow(tableId, rowId, row),
-      () => cellInvalid(tableId),
-    );
-  const validateRow = (tableId, rowId, row, skipDefaults) =>
-    objValidate(
-      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
-      (cell, cellId) =>
-        ifNotUndefined(
-          getValidatedCell(tableId, rowId, cellId, cell),
-          (validCell) => {
-            row[cellId] = validCell;
-            return true;
-          },
-          () => false,
-        ),
-      () => cellInvalid(tableId, rowId),
-    );
-  const getValidatedCell = (tableId, rowId, cellId, cell) =>
-    hasTablesSchema
-      ? ifNotUndefined(
-          mapGet(mapGet(tablesSchemaMap, tableId), cellId),
-          (cellSchema) =>
-            getCellOrValueType(cell) != cellSchema[TYPE]
-              ? cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
-              : cell,
-          () => cellInvalid(tableId, rowId, cellId, cell),
-        )
-      : isUndefined(getCellOrValueType(cell))
-        ? cellInvalid(tableId, rowId, cellId, cell)
-        : cell;
-  const validateValues = (values, skipDefaults) =>
-    objValidate(
-      skipDefaults ? values : addDefaultsToValues(values),
-      (value, valueId) =>
-        ifNotUndefined(
-          getValidatedValue(valueId, value),
-          (validValue) => {
-            values[valueId] = validValue;
-            return true;
-          },
-          () => false,
-        ),
-      () => valueInvalid(),
-    );
-  const getValidatedValue = (valueId, value) =>
-    hasValuesSchema
-      ? ifNotUndefined(
-          mapGet(valuesSchemaMap, valueId),
-          (valueSchema) =>
-            getCellOrValueType(value) != valueSchema[TYPE]
-              ? valueInvalid(valueId, value, valueSchema[DEFAULT])
-              : value,
-          () => valueInvalid(valueId, value),
-        )
-      : isUndefined(getCellOrValueType(value))
-        ? valueInvalid(valueId, value)
-        : value;
-  const addDefaultsToRow = (row, tableId, rowId) => {
-    ifNotUndefined(
-      mapGet(tablesSchemaRowCache, tableId),
-      ([rowDefaulted, rowNonDefaulted]) => {
-        collForEach(rowDefaulted, (cell, cellId) => {
-          if (!objHas(row, cellId)) {
-            row[cellId] = cell;
-          }
-        });
-        collForEach(rowNonDefaulted, (cellId) => {
-          if (!objHas(row, cellId)) {
-            cellInvalid(tableId, rowId, cellId);
-          }
-        });
-      },
-    );
-    return row;
+    return row;
   };
   const addDefaultsToValues = (values) => {
     if (hasValuesSchema) {
@@ -3238,508 +2417,1329 @@ const createStore = () => {
       [VALUE_IDS]: [0, valueIdsListeners],
       [HAS + VALUE]: [
         1,
-        hasValueListeners,
-        [getValueIds],
-        (ids) => [hasValue(...ids)],
-      ],
-      [VALUE]: [
+        hasValueListeners,
+        [getValueIds],
+        (ids) => [hasValue(...ids)],
+      ],
+      [VALUE]: [
+        1,
+        valueListeners,
+        [getValueIds],
+        (ids) => pairNew(getValue(ids[0])),
+      ],
+      InvalidValue: [1, invalidValueListeners],
+    },
+    ([argumentCount, idSetNode, pathGetters, extraArgsGetter], listenable) => {
+      store[ADD + listenable + LISTENER] = (...args) =>
+        addListener(
+          args[argumentCount],
+          idSetNode[args[argumentCount + 1] ? 1 : 0],
+          argumentCount > 0 ? slice(args, 0, argumentCount) : void 0,
+          pathGetters,
+          extraArgsGetter,
+        );
+    },
+  );
+  return objFreeze(store);
+};
+
+const LISTENER_ARGS = {
+  HasTable: 1,
+  Table: 1,
+  TableCellIds: 1,
+  HasTableCell: 2,
+  RowCount: 1,
+  RowIds: 1,
+  SortedRowIds: 5,
+  HasRow: 2,
+  Row: 2,
+  CellIds: 2,
+  HasCell: 3,
+  Cell: 3,
+  HasValue: 1,
+  Value: 1,
+  InvalidCell: 3,
+  InvalidValue: 1,
+};
+const newContentStampMap = (time = EMPTY_STRING) => [
+  stampNewMap(time),
+  stampNewMap(time),
+];
+const validateMergeableContent = (mergeableContent) =>
+  isArray(mergeableContent) &&
+  size(mergeableContent) == 2 &&
+  stampValidate(mergeableContent[0], (tableStamps) =>
+    objValidate(
+      tableStamps,
+      (tableStamp) =>
+        stampValidate(tableStamp, (rowStamps) =>
+          objValidate(
+            rowStamps,
+            (rowStamp) =>
+              stampValidate(rowStamp, (cellStamps) =>
+                objValidate(
+                  cellStamps,
+                  (cellStamp) =>
+                    stampValidate(cellStamp, isCellOrValueOrNullOrUndefined),
+                  void 0,
+                  1,
+                ),
+              ),
+            void 0,
+            1,
+          ),
+        ),
+      void 0,
+      1,
+    ),
+  ) &&
+  stampValidate(mergeableContent[1], (values) =>
+    objValidate(
+      values,
+      (value) => stampValidate(value, isCellOrValueOrNullOrUndefined),
+      void 0,
+      1,
+    ),
+  );
+const createMergeableStore = (uniqueId) => {
+  let listeningToRawStoreChanges = 1;
+  let contentStampMap = newContentStampMap();
+  let defaultingContent = 0;
+  const touchedCells = mapNew();
+  const touchedValues = setNew();
+  const [getHlc, seenHlc] = getHlcFunctions(uniqueId);
+  const store = createStore();
+  const disableListeningToRawStoreChanges = (actions) => {
+    const wasListening = listeningToRawStoreChanges;
+    listeningToRawStoreChanges = 0;
+    actions();
+    listeningToRawStoreChanges = wasListening;
+    return mergeableStore;
+  };
+  const mergeContentOrChanges = (contentOrChanges, isContent = 0) => {
+    const tablesChanges = {};
+    const valuesChanges = {};
+    const [
+      [tablesObj, incomingTablesTime = EMPTY_STRING, incomingTablesHash = 0],
+      values,
+    ] = contentOrChanges;
+    const [tablesStampMap, valuesStampMap] = contentStampMap;
+    const [tableStampMaps, oldTablesTime, oldTablesHash] = tablesStampMap;
+    let tablesHash = isContent ? incomingTablesHash : oldTablesHash;
+    let tablesTime = incomingTablesTime;
+    objForEach(
+      tablesObj,
+      (
+        [rowsObj, incomingTableTime = EMPTY_STRING, incomingTableHash = 0],
+        tableId,
+      ) => {
+        const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
+        const [rowStampMaps, oldTableTime, oldTableHash] = tableStampMap;
+        let tableHash = isContent ? incomingTableHash : oldTableHash;
+        let tableTime = incomingTableTime;
+        objForEach(rowsObj, (row, rowId) => {
+          const [rowTime, oldRowHash, rowHash] = mergeCellsOrValues(
+            row,
+            mapEnsure(rowStampMaps, rowId, stampNewMap),
+            objEnsure(objEnsure(tablesChanges, tableId, objNew), rowId, objNew),
+            isContent,
+          );
+          tableHash ^= isContent
+            ? 0
+            : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
+              hashIdAndHash(rowId, rowHash);
+          tableTime = getLatestTime(tableTime, rowTime);
+        });
+        tableHash ^= isContent
+          ? 0
+          : replaceTimeHash(oldTableTime, incomingTableTime);
+        stampUpdate(tableStampMap, incomingTableTime, tableHash);
+        tablesHash ^= isContent
+          ? 0
+          : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
+            hashIdAndHash(tableId, tableStampMap[2]);
+        tablesTime = getLatestTime(tablesTime, tableTime);
+      },
+    );
+    tablesHash ^= isContent
+      ? 0
+      : replaceTimeHash(oldTablesTime, incomingTablesTime);
+    stampUpdate(tablesStampMap, incomingTablesTime, tablesHash);
+    const [valuesTime] = mergeCellsOrValues(
+      values,
+      valuesStampMap,
+      valuesChanges,
+      isContent,
+    );
+    seenHlc(getLatestTime(tablesTime, valuesTime));
+    return [tablesChanges, valuesChanges, 1];
+  };
+  const mergeCellsOrValues = (
+    things,
+    thingsStampMap,
+    thingsChanges,
+    isContent,
+  ) => {
+    const [
+      thingsObj,
+      incomingThingsTime = EMPTY_STRING,
+      incomingThingsHash = 0,
+    ] = things;
+    const [thingStampMaps, oldThingsTime, oldThingsHash] = thingsStampMap;
+    let thingsTime = incomingThingsTime;
+    let thingsHash = isContent ? incomingThingsHash : oldThingsHash;
+    objForEach(
+      thingsObj,
+      ([thing, thingTime = EMPTY_STRING, incomingThingHash = 0], thingId) => {
+        const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
+          void 0,
+          EMPTY_STRING,
+          0,
+        ]);
+        const [, oldThingTime, oldThingHash] = thingStampMap;
+        if (!oldThingTime || thingTime > oldThingTime) {
+          stampUpdate(
+            thingStampMap,
+            thingTime,
+            isContent
+              ? incomingThingHash
+              : getHash(jsonStringWithMap(thing ?? null) + ':' + thingTime),
+          );
+          thingStampMap[0] = thing;
+          thingsChanges[thingId] = thing;
+          thingsHash ^= isContent
+            ? 0
+            : hashIdAndHash(thingId, oldThingHash) ^
+              hashIdAndHash(thingId, thingStampMap[2]);
+          thingsTime = getLatestTime(thingsTime, thingTime);
+        }
+      },
+    );
+    thingsHash ^= isContent
+      ? 0
+      : replaceTimeHash(oldThingsTime, incomingThingsTime);
+    stampUpdate(thingsStampMap, incomingThingsTime, thingsHash);
+    return [thingsTime, oldThingsHash, thingsStampMap[2]];
+  };
+  const preStartTransaction = () => {};
+  const preFinishTransaction = () => {};
+  const postFinishTransaction = () => {
+    collClear(touchedCells);
+    collClear(touchedValues);
+  };
+  const cellChanged = (tableId, rowId, cellId, newCell) => {
+    setAdd(
+      mapEnsure(mapEnsure(touchedCells, tableId, mapNew), rowId, setNew),
+      cellId,
+    );
+    if (listeningToRawStoreChanges) {
+      mergeContentOrChanges([
+        [
+          {
+            [tableId]: [
+              {
+                [rowId]: [
+                  {
+                    [cellId]: [
+                      newCell,
+                      defaultingContent ? EMPTY_STRING : getHlc(),
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [{}],
+        1,
+      ]);
+    }
+  };
+  const valueChanged = (valueId, newValue) => {
+    setAdd(touchedValues, valueId);
+    if (listeningToRawStoreChanges) {
+      mergeContentOrChanges([
+        [{}],
+        [{[valueId]: [newValue, defaultingContent ? EMPTY_STRING : getHlc()]}],
         1,
-        valueListeners,
-        [getValueIds],
-        (ids) => pairNew(getValue(ids[0])),
-      ],
-      InvalidValue: [1, invalidValueListeners],
-    },
-    ([argumentCount, idSetNode, pathGetters, extraArgsGetter], listenable) => {
-      store[ADD + listenable + LISTENER] = (...args) =>
-        addListener(
-          args[argumentCount],
-          idSetNode[args[argumentCount + 1] ? 1 : 0],
-          argumentCount > 0 ? slice(args, 0, argumentCount) : void 0,
-          pathGetters,
-          extraArgsGetter,
-        );
-    },
-  );
-  return objFreeze(store);
-};
-
-const LISTENER_ARGS = {
-  HasTable: 1,
-  Table: 1,
-  TableCellIds: 1,
-  HasTableCell: 2,
-  RowCount: 1,
-  RowIds: 1,
-  SortedRowIds: 5,
-  HasRow: 2,
-  Row: 2,
-  CellIds: 2,
-  HasCell: 3,
-  Cell: 3,
-  HasValue: 1,
-  Value: 1,
-  InvalidCell: 3,
-  InvalidValue: 1,
-};
-const newContentStampMap = (time = EMPTY_STRING) => [
-  stampNewMap(time),
-  stampNewMap(time),
-];
-const validateMergeableContent = (mergeableContent) =>
-  isArray(mergeableContent) &&
-  size(mergeableContent) == 2 &&
-  stampValidate(mergeableContent[0], (tableStamps) =>
-    objValidate(
-      tableStamps,
-      (tableStamp) =>
-        stampValidate(tableStamp, (rowStamps) =>
-          objValidate(
-            rowStamps,
-            (rowStamp) =>
-              stampValidate(rowStamp, (cellStamps) =>
-                objValidate(
-                  cellStamps,
-                  (cellStamp) =>
-                    stampValidate(cellStamp, isCellOrValueOrNullOrUndefined),
-                  void 0,
-                  1,
-                ),
-              ),
-            void 0,
-            1,
+      ]);
+    }
+  };
+  const getMergeableContent = () => [
+    stampMapToObjWithHash(contentStampMap[0], (tableStampMap) =>
+      stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
+        stampMapToObjWithHash(rowStampMap),
+      ),
+    ),
+    stampMapToObjWithHash(contentStampMap[1]),
+  ];
+  const getMergeableContentHashes = () => [
+    contentStampMap[0][2],
+    contentStampMap[1][2],
+  ];
+  const getMergeableTableHashes = () =>
+    mapToObj(contentStampMap[0][0], getStampHash);
+  const getMergeableTableDiff = (otherTableHashes) => {
+    const newTables = stampNewObj(contentStampMap[0][1]);
+    const differingTableHashes = {};
+    mapForEach(
+      contentStampMap[0][0],
+      (tableId, [tableStampMap, tableTime, hash]) =>
+        objHas(otherTableHashes, tableId)
+          ? hash != otherTableHashes[tableId]
+            ? (differingTableHashes[tableId] = hash)
+            : 0
+          : (newTables[0][tableId] = stampMapToObjWithoutHash(
+              [tableStampMap, tableTime],
+              (rowStampMap) => stampMapToObjWithoutHash(rowStampMap),
+            )),
+    );
+    return [newTables, differingTableHashes];
+  };
+  const getMergeableRowHashes = (otherTableHashes) => {
+    const rowHashes = {};
+    objForEach(otherTableHashes, (otherTableHash, tableId) =>
+      ifNotUndefined(
+        mapGet(contentStampMap[0][0], tableId),
+        ([rowStampMaps, , tableHash]) =>
+          tableHash != otherTableHash
+            ? mapForEach(
+                rowStampMaps,
+                (rowId, [, , rowHash]) =>
+                  (objEnsure(rowHashes, tableId, objNew)[rowId] = rowHash),
+              )
+            : 0,
+      ),
+    );
+    return rowHashes;
+  };
+  const getMergeableRowDiff = (otherTableRowHashes) => {
+    const newRows = stampNewObj(contentStampMap[0][1]);
+    const differingRowHashes = {};
+    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
+      mapForEach(
+        mapGet(contentStampMap[0][0], tableId)?.[0],
+        (rowId, [rowStampMap, rowTime, hash]) =>
+          objHas(otherRowHashes, rowId)
+            ? hash !== otherRowHashes[rowId]
+              ? (objEnsure(differingRowHashes, tableId, objNew)[rowId] = hash)
+              : 0
+            : (objEnsure(newRows[0], tableId, stampNewObj)[0][rowId] =
+                stampMapToObjWithoutHash([rowStampMap, rowTime])),
+      ),
+    );
+    return [newRows, differingRowHashes];
+  };
+  const getMergeableCellHashes = (otherTableRowHashes) => {
+    const cellHashes = {};
+    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
+      ifNotUndefined(mapGet(contentStampMap[0][0], tableId), ([rowStampMaps]) =>
+        objForEach(otherRowHashes, (otherRowHash, rowId) =>
+          ifNotUndefined(
+            mapGet(rowStampMaps, rowId),
+            ([cellStampMaps, , rowHash]) =>
+              rowHash !== otherRowHash
+                ? mapForEach(
+                    cellStampMaps,
+                    (cellId, [, , cellHash]) =>
+                      (objEnsure(
+                        objEnsure(cellHashes, tableId, objNew),
+                        rowId,
+                        objNew,
+                      )[cellId] = cellHash),
+                  )
+                : 0,
           ),
         ),
-      void 0,
-      1,
-    ),
-  ) &&
-  stampValidate(mergeableContent[1], (values) =>
-    objValidate(
-      values,
-      (value) => stampValidate(value, isCellOrValueOrNullOrUndefined),
-      void 0,
-      1,
-    ),
-  );
-const createMergeableStore = (uniqueId) => {
-  let listeningToRawStoreChanges = 1;
-  let contentStampMap = newContentStampMap();
-  let defaultingContent = 0;
-  const touchedCells = mapNew();
-  const touchedValues = setNew();
-  const [getHlc, seenHlc] = getHlcFunctions(uniqueId);
-  const store = createStore();
-  const disableListeningToRawStoreChanges = (actions) => {
-    const wasListening = listeningToRawStoreChanges;
-    listeningToRawStoreChanges = 0;
-    actions();
-    listeningToRawStoreChanges = wasListening;
+      ),
+    );
+    return cellHashes;
+  };
+  const getMergeableCellDiff = (otherTableRowCellHashes) => {
+    const [[tableStampMaps, tablesTime]] = contentStampMap;
+    const tablesObj = {};
+    objForEach(otherTableRowCellHashes, (otherRowCellHashes, tableId) =>
+      objForEach(otherRowCellHashes, (otherCellHashes, rowId) =>
+        ifNotUndefined(
+          mapGet(tableStampMaps, tableId),
+          ([rowStampMaps, tableTime]) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([cellStampMaps, rowTime]) =>
+                mapForEach(cellStampMaps, (cellId, [cell, cellTime, hash]) =>
+                  hash !== otherCellHashes[cellId]
+                    ? (objEnsure(
+                        objEnsure(tablesObj, tableId, () =>
+                          stampNewObj(tableTime),
+                        )[0],
+                        rowId,
+                        () => stampNewObj(rowTime),
+                      )[0][cellId] = [cell, cellTime])
+                    : 0,
+                ),
+            ),
+        ),
+      ),
+    );
+    return stampNew(tablesObj, tablesTime);
+  };
+  const getMergeableValueHashes = () =>
+    mapToObj(contentStampMap[1][0], getStampHash);
+  const getMergeableValueDiff = (otherValueHashes) => {
+    const [, [valueStampMaps, valuesTime]] = contentStampMap;
+    const values = mapToObj(
+      valueStampMaps,
+      stampClone,
+      ([, , hash], valueId) => hash == otherValueHashes?.[valueId],
+    );
+    return stampNew(values, valuesTime);
+  };
+  const setMergeableContent = (mergeableContent) =>
+    disableListeningToRawStoreChanges(() =>
+      validateMergeableContent(mergeableContent)
+        ? store.transaction(() => {
+            store.delTables().delValues();
+            contentStampMap = newContentStampMap();
+            store.applyChanges(mergeContentOrChanges(mergeableContent, 1));
+          })
+        : 0,
+    );
+  const setDefaultContent = (content) => {
+    store.transaction(() => {
+      defaultingContent = 1;
+      store.setContent(content);
+      defaultingContent = 0;
+    });
     return mergeableStore;
   };
-  const mergeContentOrChanges = (contentOrChanges, isContent = 0) => {
-    const tablesChanges = {};
-    const valuesChanges = {};
+  const getTransactionMergeableChanges = (withHashes = false) => {
     const [
-      [tablesObj, incomingTablesTime = EMPTY_STRING, incomingTablesHash = 0],
-      values,
-    ] = contentOrChanges;
-    const [tablesStampMap, valuesStampMap] = contentStampMap;
-    const [tableStampMaps, oldTablesTime, oldTablesHash] = tablesStampMap;
-    let tablesHash = isContent ? incomingTablesHash : oldTablesHash;
-    let tablesTime = incomingTablesTime;
-    objForEach(
-      tablesObj,
-      (
-        [rowsObj, incomingTableTime = EMPTY_STRING, incomingTableHash = 0],
-        tableId,
-      ) => {
-        const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
-        const [rowStampMaps, oldTableTime, oldTableHash] = tableStampMap;
-        let tableHash = isContent ? incomingTableHash : oldTableHash;
-        let tableTime = incomingTableTime;
-        objForEach(rowsObj, (row, rowId) => {
-          const [rowTime, oldRowHash, rowHash] = mergeCellsOrValues(
-            row,
-            mapEnsure(rowStampMaps, rowId, stampNewMap),
-            objEnsure(objEnsure(tablesChanges, tableId, objNew), rowId, objNew),
-            isContent,
+      [tableStampMaps, tablesTime, tablesHash],
+      [valueStampMaps, valuesTime, valuesHash],
+    ] = contentStampMap;
+    const newStamp = withHashes ? stampNewWithHash : stampNew;
+    const tablesObj = {};
+    collForEach(touchedCells, (touchedTable, tableId) =>
+      ifNotUndefined(
+        mapGet(tableStampMaps, tableId),
+        ([rowStampMaps, tableTime, tableHash]) => {
+          const tableObj = {};
+          collForEach(touchedTable, (touchedRow, rowId) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([cellStampMaps, rowTime, rowHash]) => {
+                const rowObj = {};
+                collForEach(touchedRow, (cellId) => {
+                  ifNotUndefined(
+                    mapGet(cellStampMaps, cellId),
+                    ([cell, time, hash]) =>
+                      (rowObj[cellId] = newStamp(cell, time, hash)),
+                  );
+                });
+                tableObj[rowId] = newStamp(rowObj, rowTime, rowHash);
+              },
+            ),
           );
-          tableHash ^= isContent
-            ? 0
-            : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
-              hashIdAndHash(rowId, rowHash);
-          tableTime = getLatestTime(tableTime, rowTime);
-        });
-        tableHash ^= isContent
-          ? 0
-          : replaceTimeHash(oldTableTime, incomingTableTime);
-        stampUpdate(tableStampMap, incomingTableTime, tableHash);
-        tablesHash ^= isContent
-          ? 0
-          : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
-            hashIdAndHash(tableId, tableStampMap[2]);
-        tablesTime = getLatestTime(tablesTime, tableTime);
-      },
+          tablesObj[tableId] = newStamp(tableObj, tableTime, tableHash);
+        },
+      ),
     );
-    tablesHash ^= isContent
-      ? 0
-      : replaceTimeHash(oldTablesTime, incomingTablesTime);
-    stampUpdate(tablesStampMap, incomingTablesTime, tablesHash);
-    const [valuesTime] = mergeCellsOrValues(
-      values,
-      valuesStampMap,
-      valuesChanges,
-      isContent,
+    const valuesObj = {};
+    collForEach(touchedValues, (valueId) =>
+      ifNotUndefined(
+        mapGet(valueStampMaps, valueId),
+        ([value, time, hash]) =>
+          (valuesObj[valueId] = newStamp(value, time, hash)),
+      ),
     );
-    seenHlc(getLatestTime(tablesTime, valuesTime));
-    return [tablesChanges, valuesChanges, 1];
+    return [
+      newStamp(tablesObj, tablesTime, tablesHash),
+      newStamp(valuesObj, valuesTime, valuesHash),
+      1,
+    ];
   };
-  const mergeCellsOrValues = (
-    things,
-    thingsStampMap,
-    thingsChanges,
-    isContent,
+  const applyMergeableChanges = (mergeableChanges) =>
+    disableListeningToRawStoreChanges(() =>
+      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
+    );
+  const merge = (mergeableStore2) => {
+    const mergeableChanges = getMergeableContent();
+    const mergeableChanges2 = mergeableStore2.getMergeableContent();
+    mergeableStore2.applyMergeableChanges(mergeableChanges);
+    return applyMergeableChanges(mergeableChanges2);
+  };
+  const mergeableStore = {
+    getMergeableContent,
+    getMergeableContentHashes,
+    getMergeableTableHashes,
+    getMergeableTableDiff,
+    getMergeableRowHashes,
+    getMergeableRowDiff,
+    getMergeableCellHashes,
+    getMergeableCellDiff,
+    getMergeableValueHashes,
+    getMergeableValueDiff,
+    setMergeableContent,
+    setDefaultContent,
+    getTransactionMergeableChanges,
+    applyMergeableChanges,
+    merge,
+  };
+  store.setInternalListeners(
+    preStartTransaction,
+    preFinishTransaction,
+    postFinishTransaction,
+    cellChanged,
+    valueChanged,
+  );
+  objMap(
+    store,
+    (method, name) =>
+      (mergeableStore[name] = // fluent methods
+        strStartsWith(name, SET) ||
+        strStartsWith(name, DEL) ||
+        strStartsWith(name, 'apply') ||
+        strEndsWith(name, TRANSACTION) ||
+        name == 'call' + LISTENER
+          ? (...args) => {
+              method(...args);
+              return mergeableStore;
+            }
+          : strStartsWith(name, ADD) && strEndsWith(name, LISTENER)
+            ? (...args) => {
+                const listenerArg = LISTENER_ARGS[slice(name, 3, -8)] ?? 0;
+                const listener = args[listenerArg];
+                args[listenerArg] = (_store, ...args2) =>
+                  listener(mergeableStore, ...args2);
+                return method(...args);
+              }
+            : name == 'isMergeable'
+              ? () => true
+              : method),
+  );
+  return objFreeze(mergeableStore);
+};
+
+const numericAggregators = /* @__PURE__ */ mapNew([
+  [
+    AVG,
+    [
+      (numbers, length) => arraySum(numbers) / length,
+      (metric, add, length) => metric + (add - metric) / (length + 1),
+      (metric, remove, length) => metric + (metric - remove) / (length - 1),
+      (metric, add, remove, length) => metric + (add - remove) / length,
+    ],
+  ],
+  [
+    MAX,
+    [
+      (numbers) => mathMax(...numbers),
+      (metric, add) => mathMax(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMax(add, metric),
+    ],
+  ],
+  [
+    MIN,
+    [
+      (numbers) => mathMin(...numbers),
+      (metric, add) => mathMin(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMin(add, metric),
+    ],
+  ],
+  [
+    SUM,
+    [
+      (numbers) => arraySum(numbers),
+      (metric, add) => metric + add,
+      (metric, remove) => metric - remove,
+      (metric, add, remove) => metric - remove + add,
+    ],
+  ],
+]);
+const getAggregateValue = (
+  aggregateValue,
+  oldLength,
+  newValues,
+  changedValues,
+  aggregators,
+  force = false,
+) => {
+  if (collIsEmpty(newValues)) {
+    return void 0;
+  }
+  const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =
+    aggregators;
+  force ||= isUndefined(aggregateValue);
+  collForEach(changedValues, ([oldValue, newValue]) => {
+    if (!force) {
+      aggregateValue = isUndefined(oldValue)
+        ? aggregateAdd?.(aggregateValue, newValue, oldLength++)
+        : isUndefined(newValue)
+          ? aggregateRemove?.(aggregateValue, oldValue, oldLength--)
+          : aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);
+      force ||= isUndefined(aggregateValue);
+    }
+  });
+  return force
+    ? aggregate(collValues(newValues), collSize(newValues))
+    : aggregateValue;
+};
+
+const createMetrics = getCreateFunction((store) => {
+  const metricListeners = mapNew();
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => metrics,
+  );
+  const [
+    getStore,
+    getMetricIds,
+    forEachMetric,
+    hasMetric,
+    getTableId,
+    getMetric,
+    setMetric,
+    ,
+    setDefinitionAndListen,
+    delDefinition,
+    addMetricIdsListener,
+    destroy,
+  ] = getDefinableFunctions(
+    store,
+    getUndefined,
+    (value) =>
+      isNaN(value) ||
+      isUndefined(value) ||
+      value === true ||
+      value === false ||
+      value === EMPTY_STRING
+        ? void 0
+        : value * 1,
+    addListener,
+    callListeners,
+  );
+  const setMetricDefinition = (
+    metricId,
+    tableId,
+    aggregate,
+    getNumber,
+    aggregateAdd,
+    aggregateRemove,
+    aggregateReplace,
   ) => {
-    const [
-      thingsObj,
-      incomingThingsTime = EMPTY_STRING,
-      incomingThingsHash = 0,
-    ] = things;
-    const [thingStampMaps, oldThingsTime, oldThingsHash] = thingsStampMap;
-    let thingsTime = incomingThingsTime;
-    let thingsHash = isContent ? incomingThingsHash : oldThingsHash;
-    objForEach(
-      thingsObj,
-      ([thing, thingTime = EMPTY_STRING, incomingThingHash = 0], thingId) => {
-        const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
-          void 0,
-          EMPTY_STRING,
-          0,
-        ]);
-        const [, oldThingTime, oldThingHash] = thingStampMap;
-        if (!oldThingTime || thingTime > oldThingTime) {
-          stampUpdate(
-            thingStampMap,
-            thingTime,
-            isContent
-              ? incomingThingHash
-              : getHash(jsonStringWithMap(thing ?? null) + ':' + thingTime),
-          );
-          thingStampMap[0] = thing;
-          thingsChanges[thingId] = thing;
-          thingsHash ^= isContent
-            ? 0
-            : hashIdAndHash(thingId, oldThingHash) ^
-              hashIdAndHash(thingId, thingStampMap[2]);
-          thingsTime = getLatestTime(thingsTime, thingTime);
+    const aggregators = isFunction(aggregate)
+      ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
+      : (mapGet(numericAggregators, aggregate) ??
+        mapGet(numericAggregators, SUM));
+    setDefinitionAndListen(
+      metricId,
+      tableId,
+      (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
+        const oldMetric = getMetric(metricId);
+        const oldLength = collSize(numbers);
+        force ||= isUndefined(oldMetric);
+        change();
+        let newMetric = getAggregateValue(
+          oldMetric,
+          oldLength,
+          numbers,
+          changedNumbers,
+          aggregators,
+          force,
+        );
+        if (!isFiniteNumber(newMetric)) {
+          newMetric = void 0;
+        }
+        if (newMetric != oldMetric) {
+          setMetric(metricId, newMetric);
+          callListeners(metricListeners, [metricId], newMetric, oldMetric);
         }
       },
+      getRowCellFunction(getNumber, 1),
     );
-    thingsHash ^= isContent
-      ? 0
-      : replaceTimeHash(oldThingsTime, incomingThingsTime);
-    stampUpdate(thingsStampMap, incomingThingsTime, thingsHash);
-    return [thingsTime, oldThingsHash, thingsStampMap[2]];
+    return metrics;
   };
-  const preStartTransaction = () => {};
-  const preFinishTransaction = () => {};
-  const postFinishTransaction = () => {
-    collClear(touchedCells);
-    collClear(touchedValues);
+  const delMetricDefinition = (metricId) => {
+    delDefinition(metricId);
+    return metrics;
   };
-  const cellChanged = (tableId, rowId, cellId, newCell) => {
-    setAdd(
-      mapEnsure(mapEnsure(touchedCells, tableId, mapNew), rowId, setNew),
-      cellId,
+  const addMetricListener = (metricId, listener) =>
+    addListener(listener, metricListeners, [metricId]);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return metrics;
+  };
+  const getListenerStats = () => ({
+    metric: collSize2(metricListeners),
+  });
+  const metrics = {
+    setMetricDefinition,
+    delMetricDefinition,
+    getStore,
+    getMetricIds,
+    forEachMetric,
+    hasMetric,
+    getTableId,
+    getMetric,
+    addMetricIdsListener,
+    addMetricListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(metrics);
+});
+
+const createQueries = getCreateFunction((store) => {
+  const createStore = store.createStore;
+  const preStore = createStore();
+  const resultStore = createStore();
+  const preStoreListenerIds = mapNew();
+  const {
+    addListener,
+    callListeners,
+    delListener: delListenerImpl,
+  } = resultStore;
+  const [
+    getStore,
+    getQueryIds,
+    forEachQuery,
+    hasQuery,
+    getTableId,
+    ,
+    ,
+    setDefinition,
+    ,
+    delDefinition,
+    addQueryIdsListenerImpl,
+    destroy,
+    addStoreListeners,
+    delStoreListeners,
+  ] = getDefinableFunctions(
+    store,
+    () => true,
+    getUndefined,
+    addListener,
+    callListeners,
+  );
+  const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
+    arrayForEach(listenerIds, (listenerId) =>
+      setAdd(
+        mapEnsure(
+          mapEnsure(preStoreListenerIds, queryId, mapNew),
+          preStore2,
+          setNew,
+        ),
+        listenerId,
+      ),
+    );
+  const resetPreStores = (queryId) => {
+    ifNotUndefined(
+      mapGet(preStoreListenerIds, queryId),
+      (queryPreStoreListenerIds) => {
+        mapForEach(queryPreStoreListenerIds, (preStore2, listenerIds) =>
+          collForEach(listenerIds, (listenerId) =>
+            preStore2.delListener(listenerId),
+          ),
+        );
+        collClear(queryPreStoreListenerIds);
+      },
+    );
+    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
+  };
+  const synchronizeTransactions = (queryId, fromStore, toStore) =>
+    addPreStoreListener(
+      fromStore,
+      queryId,
+      fromStore.addStartTransactionListener(toStore.startTransaction),
+      fromStore.addDidFinishTransactionListener(() =>
+        toStore.finishTransaction(),
+      ),
+    );
+  const setQueryDefinition = (queryId, tableId, build) => {
+    setDefinition(queryId, tableId);
+    resetPreStores(queryId);
+    const selectEntries = [];
+    const joinEntries = [[null, [tableId, null, null, [], mapNew()]]];
+    const wheres = [];
+    const groupEntries = [];
+    const havings = [];
+    const select = (arg1, arg2) => {
+      const selectEntry = isFunction(arg1)
+        ? [size(selectEntries) + EMPTY_STRING, arg1]
+        : [
+            isUndefined(arg2) ? arg1 : arg2,
+            (getTableCell) => getTableCell(arg1, arg2),
+          ];
+      arrayPush(selectEntries, selectEntry);
+      return {as: (selectedCellId) => (selectEntry[0] = selectedCellId)};
+    };
+    const join = (joinedTableId, arg1, arg2) => {
+      const fromIntermediateJoinedTableId =
+        isUndefined(arg2) || isFunction(arg1) ? null : arg1;
+      const onArg = isUndefined(fromIntermediateJoinedTableId) ? arg1 : arg2;
+      const joinEntry = [
+        joinedTableId,
+        [
+          joinedTableId,
+          fromIntermediateJoinedTableId,
+          isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
+          [],
+          mapNew(),
+        ],
+      ];
+      arrayPush(joinEntries, joinEntry);
+      return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};
+    };
+    const where = (arg1, arg2, arg3) =>
+      arrayPush(
+        wheres,
+        isFunction(arg1)
+          ? arg1
+          : isUndefined(arg3)
+            ? (getTableCell) => getTableCell(arg1) === arg2
+            : (getTableCell) => getTableCell(arg1, arg2) === arg3,
+      );
+    const group = (
+      selectedCellId,
+      aggregate,
+      aggregateAdd,
+      aggregateRemove,
+      aggregateReplace,
+    ) => {
+      const groupEntry = [
+        selectedCellId,
+        [
+          selectedCellId,
+          isFunction(aggregate)
+            ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
+            : (mapGet(numericAggregators, aggregate) ?? [
+                (_cells, length) => length,
+              ]),
+        ],
+      ];
+      arrayPush(groupEntries, groupEntry);
+      return {as: (groupedCellId) => (groupEntry[0] = groupedCellId)};
+    };
+    const having = (arg1, arg2) =>
+      arrayPush(
+        havings,
+        isFunction(arg1)
+          ? arg1
+          : (getSelectedOrGroupedCell) =>
+              getSelectedOrGroupedCell(arg1) === arg2,
+      );
+    build({select, join, where, group, having});
+    const selects = mapNew(selectEntries);
+    if (collIsEmpty(selects)) {
+      return queries;
+    }
+    const joins = mapNew(joinEntries);
+    mapForEach(joins, (asTableId, [, fromAsTableId]) =>
+      ifNotUndefined(mapGet(joins, fromAsTableId), ({3: toAsTableIds}) =>
+        isUndefined(asTableId) ? 0 : arrayPush(toAsTableIds, asTableId),
+      ),
     );
-    if (listeningToRawStoreChanges) {
-      mergeContentOrChanges([
-        [
-          {
-            [tableId]: [
-              {
-                [rowId]: [
-                  {
-                    [cellId]: [
-                      newCell,
-                      defaultingContent ? EMPTY_STRING : getHlc(),
-                    ],
-                  },
-                ],
+    const groups = mapNew(groupEntries);
+    let selectJoinWhereStore = preStore;
+    if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
+      selectJoinWhereStore = resultStore;
+    } else {
+      synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);
+      const groupedSelectedCellIds = mapNew();
+      mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
+        setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
+          groupedCellId,
+          aggregators,
+        ]),
+      );
+      const groupBySelectedCellIds = setNew();
+      mapForEach(selects, (selectedCellId) =>
+        collHas(groupedSelectedCellIds, selectedCellId)
+          ? 0
+          : setAdd(groupBySelectedCellIds, selectedCellId),
+      );
+      const tree = mapNew();
+      const writeGroupRow = (
+        leaf,
+        changedGroupedSelectedCells,
+        selectedRowId,
+        forceRemove,
+      ) =>
+        ifNotUndefined(
+          leaf,
+          ([selectedCells, selectedRowIds, groupRowId, groupRow]) => {
+            mapForEach(
+              changedGroupedSelectedCells,
+              (selectedCellId, [newCell]) => {
+                const selectedCell = mapEnsure(
+                  selectedCells,
+                  selectedCellId,
+                  mapNew,
+                );
+                const oldLeafCell = mapGet(selectedCell, selectedRowId);
+                const newLeafCell = forceRemove ? void 0 : newCell;
+                if (oldLeafCell !== newLeafCell) {
+                  const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);
+                  const oldLength = collSize(selectedCell);
+                  mapSet(selectedCell, selectedRowId, newLeafCell);
+                  collForEach(
+                    mapGet(groupedSelectedCellIds, selectedCellId),
+                    ([groupedCellId, aggregators]) => {
+                      const aggregateValue = getAggregateValue(
+                        groupRow[groupedCellId],
+                        oldLength,
+                        selectedCell,
+                        oldNewSet,
+                        aggregators,
+                      );
+                      groupRow[groupedCellId] = isUndefined(
+                        getCellOrValueType(aggregateValue),
+                      )
+                        ? null
+                        : aggregateValue;
+                    },
+                  );
+                }
               },
-            ],
+            );
+            if (
+              collIsEmpty(selectedRowIds) ||
+              !arrayEvery(havings, (having2) =>
+                having2((cellId) => groupRow[cellId]),
+              )
+            ) {
+              resultStore.delRow(queryId, groupRowId);
+            } else if (isUndefined(groupRowId)) {
+              leaf[2] = resultStore.addRow(queryId, groupRow);
+            } else {
+              resultStore.setRow(queryId, groupRowId, groupRow);
+            }
           },
-        ],
-        [{}],
-        1,
-      ]);
+        );
+      addPreStoreListener(
+        selectJoinWhereStore,
+        queryId,
+        selectJoinWhereStore.addRowListener(
+          queryId,
+          null,
+          (_store, _tableId, selectedRowId, getCellChange) => {
+            const oldPath = [];
+            const newPath = [];
+            const changedGroupedSelectedCells = mapNew();
+            const rowExists = selectJoinWhereStore.hasRow(
+              queryId,
+              selectedRowId,
+            );
+            let changedLeaf = !rowExists;
+            collForEach(groupBySelectedCellIds, (selectedCellId) => {
+              const [changed, oldCell, newCell] = getCellChange(
+                queryId,
+                selectedRowId,
+                selectedCellId,
+              );
+              arrayPush(oldPath, oldCell);
+              arrayPush(newPath, newCell);
+              changedLeaf ||= changed;
+            });
+            mapForEach(groupedSelectedCellIds, (selectedCellId) => {
+              const [changed, , newCell] = getCellChange(
+                queryId,
+                selectedRowId,
+                selectedCellId,
+              );
+              if (changedLeaf || changed) {
+                mapSet(changedGroupedSelectedCells, selectedCellId, [newCell]);
+              }
+            });
+            if (changedLeaf) {
+              writeGroupRow(
+                visitTree(tree, oldPath, void 0, ([, selectedRowIds]) => {
+                  collDel(selectedRowIds, selectedRowId);
+                  return collIsEmpty(selectedRowIds);
+                }),
+                changedGroupedSelectedCells,
+                selectedRowId,
+                1,
+              );
+            }
+            if (rowExists) {
+              writeGroupRow(
+                visitTree(
+                  tree,
+                  newPath,
+                  () => {
+                    const groupRow = {};
+                    collForEach(
+                      groupBySelectedCellIds,
+                      (selectedCellId) =>
+                        (groupRow[selectedCellId] =
+                          selectJoinWhereStore.getCell(
+                            queryId,
+                            selectedRowId,
+                            selectedCellId,
+                          )),
+                    );
+                    return [mapNew(), setNew(), void 0, groupRow];
+                  },
+                  ([, selectedRowIds]) => {
+                    setAdd(selectedRowIds, selectedRowId);
+                  },
+                ),
+                changedGroupedSelectedCells,
+                selectedRowId,
+              );
+            }
+          },
+        ),
+      );
     }
-  };
-  const valueChanged = (valueId, newValue) => {
-    setAdd(touchedValues, valueId);
-    if (listeningToRawStoreChanges) {
-      mergeContentOrChanges([
-        [{}],
-        [{[valueId]: [newValue, defaultingContent ? EMPTY_STRING : getHlc()]}],
+    synchronizeTransactions(queryId, store, selectJoinWhereStore);
+    const writeSelectRow = (rootRowId) => {
+      const getTableCell = (arg1, arg2) =>
+        store.getCell(
+          ...(isUndefined(arg2)
+            ? [tableId, rootRowId, arg1]
+            : arg1 === tableId
+              ? [tableId, rootRowId, arg2]
+              : [
+                  mapGet(joins, arg1)?.[0],
+                  mapGet(mapGet(joins, arg1)?.[4], rootRowId)?.[0],
+                  arg2,
+                ]),
+        );
+      selectJoinWhereStore.transaction(() =>
+        arrayEvery(wheres, (where2) => where2(getTableCell))
+          ? mapForEach(selects, (asCellId, tableCellGetter) =>
+              setOrDelCell(
+                selectJoinWhereStore,
+                queryId,
+                rootRowId,
+                asCellId,
+                tableCellGetter(getTableCell, rootRowId),
+              ),
+            )
+          : selectJoinWhereStore.delRow(queryId, rootRowId),
+      );
+    };
+    const listenToTable = (rootRowId, tableId2, rowId, joinedTableIds2) => {
+      const getCell = (cellId) => store.getCell(tableId2, rowId, cellId);
+      arrayForEach(joinedTableIds2, (remoteAsTableId) => {
+        const [realJoinedTableId, , on, nextJoinedTableIds, remoteIdPair] =
+          mapGet(joins, remoteAsTableId);
+        const remoteRowId = on?.(getCell, rootRowId);
+        const [previousRemoteRowId, previousRemoteListenerId] =
+          mapGet(remoteIdPair, rootRowId) ?? [];
+        if (remoteRowId != previousRemoteRowId) {
+          if (!isUndefined(previousRemoteListenerId)) {
+            delStoreListeners(queryId, previousRemoteListenerId);
+          }
+          mapSet(
+            remoteIdPair,
+            rootRowId,
+            isUndefined(remoteRowId)
+              ? null
+              : [
+                  remoteRowId,
+                  ...addStoreListeners(
+                    queryId,
+                    1,
+                    store.addRowListener(realJoinedTableId, remoteRowId, () =>
+                      listenToTable(
+                        rootRowId,
+                        realJoinedTableId,
+                        remoteRowId,
+                        nextJoinedTableIds,
+                      ),
+                    ),
+                  ),
+                ],
+          );
+        }
+      });
+      writeSelectRow(rootRowId);
+    };
+    const {3: joinedTableIds} = mapGet(joins, null);
+    selectJoinWhereStore.transaction(() =>
+      addStoreListeners(
+        queryId,
         1,
-      ]);
-    }
-  };
-  const getMergeableContent = () => [
-    stampMapToObjWithHash(contentStampMap[0], (tableStampMap) =>
-      stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
-        stampMapToObjWithHash(rowStampMap),
+        store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {
+          if (store.hasRow(tableId, rootRowId)) {
+            listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);
+          } else {
+            selectJoinWhereStore.delRow(queryId, rootRowId);
+            collForEach(joins, ({4: idsByRootRowId}) =>
+              ifNotUndefined(
+                mapGet(idsByRootRowId, rootRowId),
+                ([, listenerId]) => {
+                  delStoreListeners(queryId, listenerId);
+                  mapSet(idsByRootRowId, rootRowId);
+                },
+              ),
+            );
+          }
+        }),
       ),
-    ),
-    stampMapToObjWithHash(contentStampMap[1]),
-  ];
-  const getMergeableContentHashes = () => [
-    contentStampMap[0][2],
-    contentStampMap[1][2],
-  ];
-  const getMergeableTableHashes = () =>
-    mapToObj(contentStampMap[0][0], getStampHash);
-  const getMergeableTableDiff = (otherTableHashes) => {
-    const newTables = stampNewObj(contentStampMap[0][1]);
-    const differingTableHashes = {};
-    mapForEach(
-      contentStampMap[0][0],
-      (tableId, [tableStampMap, tableTime, hash]) =>
-        objHas(otherTableHashes, tableId)
-          ? hash != otherTableHashes[tableId]
-            ? (differingTableHashes[tableId] = hash)
-            : 0
-          : (newTables[0][tableId] = stampMapToObjWithoutHash(
-              [tableStampMap, tableTime],
-              (rowStampMap) => stampMapToObjWithoutHash(rowStampMap),
-            )),
     );
-    return [newTables, differingTableHashes];
+    return queries;
   };
-  const getMergeableRowHashes = (otherTableHashes) => {
-    const rowHashes = {};
-    objForEach(otherTableHashes, (otherTableHash, tableId) =>
-      ifNotUndefined(
-        mapGet(contentStampMap[0][0], tableId),
-        ([rowStampMaps, , tableHash]) =>
-          tableHash != otherTableHash
-            ? mapForEach(
-                rowStampMaps,
-                (rowId, [, , rowHash]) =>
-                  (objEnsure(rowHashes, tableId, objNew)[rowId] = rowHash),
-              )
-            : 0,
-      ),
-    );
-    return rowHashes;
+  const delQueryDefinition = (queryId) => {
+    resetPreStores(queryId);
+    delDefinition(queryId);
+    return queries;
   };
-  const getMergeableRowDiff = (otherTableRowHashes) => {
-    const newRows = stampNewObj(contentStampMap[0][1]);
-    const differingRowHashes = {};
-    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
-      mapForEach(
-        mapGet(contentStampMap[0][0], tableId)?.[0],
-        (rowId, [rowStampMap, rowTime, hash]) =>
-          objHas(otherRowHashes, rowId)
-            ? hash !== otherRowHashes[rowId]
-              ? (objEnsure(differingRowHashes, tableId, objNew)[rowId] = hash)
-              : 0
-            : (objEnsure(newRows[0], tableId, stampNewObj)[0][rowId] =
-                stampMapToObjWithoutHash([rowStampMap, rowTime])),
-      ),
-    );
-    return [newRows, differingRowHashes];
+  const addQueryIdsListener = (listener) =>
+    addQueryIdsListenerImpl(() => listener(queries));
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return queries;
   };
-  const getMergeableCellHashes = (otherTableRowHashes) => {
-    const cellHashes = {};
-    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
-      ifNotUndefined(mapGet(contentStampMap[0][0], tableId), ([rowStampMaps]) =>
-        objForEach(otherRowHashes, (otherRowHash, rowId) =>
-          ifNotUndefined(
-            mapGet(rowStampMaps, rowId),
-            ([cellStampMaps, , rowHash]) =>
-              rowHash !== otherRowHash
-                ? mapForEach(
-                    cellStampMaps,
-                    (cellId, [, , cellHash]) =>
-                      (objEnsure(
-                        objEnsure(cellHashes, tableId, objNew),
-                        rowId,
-                        objNew,
-                      )[cellId] = cellHash),
-                  )
-                : 0,
-          ),
-        ),
-      ),
-    );
-    return cellHashes;
+  const getListenerStats = () => {
+    const {
+      tables: _1,
+      tableIds: _2,
+      transaction: _3,
+      ...stats
+    } = resultStore.getListenerStats();
+    return stats;
   };
-  const getMergeableCellDiff = (otherTableRowCellHashes) => {
-    const [[tableStampMaps, tablesTime]] = contentStampMap;
-    const tablesObj = {};
-    objForEach(otherTableRowCellHashes, (otherRowCellHashes, tableId) =>
-      objForEach(otherRowCellHashes, (otherCellHashes, rowId) =>
-        ifNotUndefined(
-          mapGet(tableStampMaps, tableId),
-          ([rowStampMaps, tableTime]) =>
-            ifNotUndefined(
-              mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime]) =>
-                mapForEach(cellStampMaps, (cellId, [cell, cellTime, hash]) =>
-                  hash !== otherCellHashes[cellId]
-                    ? (objEnsure(
-                        objEnsure(tablesObj, tableId, () =>
-                          stampNewObj(tableTime),
-                        )[0],
-                        rowId,
-                        () => stampNewObj(rowTime),
-                      )[0][cellId] = [cell, cellTime])
-                    : 0,
-                ),
-            ),
-        ),
-      ),
-    );
-    return stampNew(tablesObj, tablesTime);
+  const queries = {
+    setQueryDefinition,
+    delQueryDefinition,
+    getStore,
+    getQueryIds,
+    forEachQuery,
+    hasQuery,
+    getTableId,
+    addQueryIdsListener,
+    delListener,
+    destroy,
+    getListenerStats,
   };
-  const getMergeableValueHashes = () =>
-    mapToObj(contentStampMap[1][0], getStampHash);
-  const getMergeableValueDiff = (otherValueHashes) => {
-    const [, [valueStampMaps, valuesTime]] = contentStampMap;
-    const values = mapToObj(
-      valueStampMaps,
-      stampClone,
-      ([, , hash], valueId) => hash == otherValueHashes?.[valueId],
+  objMap(
+    {
+      [TABLE]: [1, 1],
+      [TABLE + CELL_IDS]: [0, 1],
+      [ROW_COUNT]: [0, 1],
+      [ROW_IDS]: [0, 1],
+      [SORTED_ROW_IDS]: [0, 5],
+      [ROW]: [1, 2],
+      [CELL_IDS]: [0, 2],
+      [CELL]: [1, 3],
+    },
+    ([hasAndForEach, argumentCount], gettable) => {
+      arrayForEach(
+        hasAndForEach ? [GET, 'has', 'forEach'] : [GET],
+        (prefix) =>
+          (queries[prefix + RESULT + gettable] = (...args) =>
+            resultStore[prefix + gettable](...args)),
+      );
+      queries[ADD + RESULT + gettable + LISTENER] = (...args) =>
+        resultStore[ADD + gettable + LISTENER](
+          ...slice(args, 0, argumentCount),
+          (_store, ...listenerArgs) =>
+            args[argumentCount](queries, ...listenerArgs),
+          true,
+        );
+    },
+  );
+  return objFreeze(queries);
+});
+
+const createRelationships = getCreateFunction((store) => {
+  const remoteTableIds = mapNew();
+  const remoteRowIdListeners = mapNew();
+  const localRowIdsListeners = mapNew();
+  const linkedRowIdsListeners = mapNew();
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => relationships,
+  );
+  const [
+    getStore,
+    getRelationshipIds,
+    forEachRelationshipImpl,
+    hasRelationship,
+    getLocalTableId,
+    getRelationship,
+    ,
+    ,
+    setDefinitionAndListen,
+    delDefinition,
+    addRelationshipIdsListener,
+    destroy,
+  ] = getDefinableFunctions(
+    store,
+    () => [mapNew(), mapNew(), mapNew(), mapNew()],
+    (value) => (isUndefined(value) ? void 0 : value + EMPTY_STRING),
+    addListener,
+    callListeners,
+  );
+  const getLinkedRowIdsCache = (relationshipId, firstRowId, skipCache) =>
+    ifNotUndefined(
+      getRelationship(relationshipId),
+      ([remoteRows, , linkedRowsCache]) => {
+        if (!collHas(linkedRowsCache, firstRowId)) {
+          const linkedRows = setNew();
+          if (
+            getLocalTableId(relationshipId) != getRemoteTableId(relationshipId)
+          ) {
+            setAdd(linkedRows, firstRowId);
+          } else {
+            let rowId = firstRowId;
+            while (!isUndefined(rowId) && !collHas(linkedRows, rowId)) {
+              setAdd(linkedRows, rowId);
+              rowId = mapGet(remoteRows, rowId);
+            }
+          }
+          if (skipCache) {
+            return linkedRows;
+          }
+          mapSet(linkedRowsCache, firstRowId, linkedRows);
+        }
+        return mapGet(linkedRowsCache, firstRowId);
+      },
     );
-    return stampNew(values, valuesTime);
-  };
-  const setMergeableContent = (mergeableContent) =>
-    disableListeningToRawStoreChanges(() =>
-      validateMergeableContent(mergeableContent)
-        ? store.transaction(() => {
-            store.delTables().delValues();
-            contentStampMap = newContentStampMap();
-            store.applyChanges(mergeContentOrChanges(mergeableContent, 1));
-          })
-        : 0,
+  const delLinkedRowIdsCache = (relationshipId, firstRowId) =>
+    ifNotUndefined(getRelationship(relationshipId), ([, , linkedRowsCache]) =>
+      mapSet(linkedRowsCache, firstRowId),
     );
-  const setDefaultContent = (content) => {
-    store.transaction(() => {
-      defaultingContent = 1;
-      store.setContent(content);
-      defaultingContent = 0;
-    });
-    return mergeableStore;
-  };
-  const getTransactionMergeableChanges = (withHashes = false) => {
-    const [
-      [tableStampMaps, tablesTime, tablesHash],
-      [valueStampMaps, valuesTime, valuesHash],
-    ] = contentStampMap;
-    const newStamp = withHashes ? stampNewWithHash : stampNew;
-    const tablesObj = {};
-    collForEach(touchedCells, (touchedTable, tableId) =>
-      ifNotUndefined(
-        mapGet(tableStampMaps, tableId),
-        ([rowStampMaps, tableTime, tableHash]) => {
-          const tableObj = {};
-          collForEach(touchedTable, (touchedRow, rowId) =>
-            ifNotUndefined(
-              mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime, rowHash]) => {
-                const rowObj = {};
-                collForEach(touchedRow, (cellId) => {
-                  ifNotUndefined(
-                    mapGet(cellStampMaps, cellId),
-                    ([cell, time, hash]) =>
-                      (rowObj[cellId] = newStamp(cell, time, hash)),
-                  );
-                });
-                tableObj[rowId] = newStamp(rowObj, rowTime, rowHash);
+  const setRelationshipDefinition = (
+    relationshipId,
+    localTableId,
+    remoteTableId,
+    getRemoteRowId2,
+  ) => {
+    mapSet(remoteTableIds, relationshipId, remoteTableId);
+    setDefinitionAndListen(
+      relationshipId,
+      localTableId,
+      (change, changedRemoteRowIds) => {
+        const changedLocalRows = setNew();
+        const changedRemoteRows = setNew();
+        const changedLinkedRows = setNew();
+        const [localRows, remoteRows] = getRelationship(relationshipId);
+        collForEach(
+          changedRemoteRowIds,
+          ([oldRemoteRowId, newRemoteRowId], localRowId) => {
+            if (!isUndefined(oldRemoteRowId)) {
+              setAdd(changedRemoteRows, oldRemoteRowId);
+              ifNotUndefined(
+                mapGet(remoteRows, oldRemoteRowId),
+                (oldRemoteRow) => {
+                  collDel(oldRemoteRow, localRowId);
+                  if (collIsEmpty(oldRemoteRow)) {
+                    mapSet(remoteRows, oldRemoteRowId);
+                  }
+                },
+              );
+            }
+            if (!isUndefined(newRemoteRowId)) {
+              setAdd(changedRemoteRows, newRemoteRowId);
+              if (!collHas(remoteRows, newRemoteRowId)) {
+                mapSet(remoteRows, newRemoteRowId, setNew());
+              }
+              setAdd(mapGet(remoteRows, newRemoteRowId), localRowId);
+            }
+            setAdd(changedLocalRows, localRowId);
+            mapSet(localRows, localRowId, newRemoteRowId);
+            mapForEach(
+              mapGet(linkedRowIdsListeners, relationshipId),
+              (firstRowId) => {
+                if (
+                  collHas(
+                    getLinkedRowIdsCache(relationshipId, firstRowId),
+                    localRowId,
+                  )
+                ) {
+                  setAdd(changedLinkedRows, firstRowId);
+                }
               },
-            ),
-          );
-          tablesObj[tableId] = newStamp(tableObj, tableTime, tableHash);
-        },
-      ),
+            );
+          },
+        );
+        change();
+        collForEach(changedLocalRows, (localRowId) =>
+          callListeners(remoteRowIdListeners, [relationshipId, localRowId]),
+        );
+        collForEach(changedRemoteRows, (remoteRowId) =>
+          callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),
+        );
+        collForEach(changedLinkedRows, (firstRowId) => {
+          delLinkedRowIdsCache(relationshipId, firstRowId);
+          callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);
+        });
+      },
+      getRowCellFunction(getRemoteRowId2),
     );
-    const valuesObj = {};
-    collForEach(touchedValues, (valueId) =>
-      ifNotUndefined(
-        mapGet(valueStampMaps, valueId),
-        ([value, time, hash]) =>
-          (valuesObj[valueId] = newStamp(value, time, hash)),
+    return relationships;
+  };
+  const forEachRelationship = (relationshipCallback) =>
+    forEachRelationshipImpl((relationshipId) =>
+      relationshipCallback(relationshipId, (rowCallback) =>
+        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
       ),
     );
-    return [
-      newStamp(tablesObj, tablesTime, tablesHash),
-      newStamp(valuesObj, valuesTime, valuesHash),
-      1,
-    ];
+  const delRelationshipDefinition = (relationshipId) => {
+    mapSet(remoteTableIds, relationshipId);
+    delDefinition(relationshipId);
+    return relationships;
   };
-  const applyMergeableChanges = (mergeableChanges) =>
-    disableListeningToRawStoreChanges(() =>
-      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
-    );
-  const merge = (mergeableStore2) => {
-    const mergeableChanges = getMergeableContent();
-    const mergeableChanges2 = mergeableStore2.getMergeableContent();
-    mergeableStore2.applyMergeableChanges(mergeableChanges);
-    return applyMergeableChanges(mergeableChanges2);
+  const getRemoteTableId = (relationshipId) =>
+    mapGet(remoteTableIds, relationshipId);
+  const getRemoteRowId = (relationshipId, localRowId) =>
+    mapGet(getRelationship(relationshipId)?.[0], localRowId);
+  const getLocalRowIds = (relationshipId, remoteRowId) =>
+    collValues(mapGet(getRelationship(relationshipId)?.[1], remoteRowId));
+  const getLinkedRowIds = (relationshipId, firstRowId) =>
+    isUndefined(getRelationship(relationshipId))
+      ? [firstRowId]
+      : collValues(getLinkedRowIdsCache(relationshipId, firstRowId, true));
+  const addRemoteRowIdListener = (relationshipId, localRowId, listener) =>
+    addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);
+  const addLocalRowIdsListener = (relationshipId, remoteRowId, listener) =>
+    addListener(listener, localRowIdsListeners, [relationshipId, remoteRowId]);
+  const addLinkedRowIdsListener = (relationshipId, firstRowId, listener) => {
+    getLinkedRowIdsCache(relationshipId, firstRowId);
+    return addListener(listener, linkedRowIdsListeners, [
+      relationshipId,
+      firstRowId,
+    ]);
   };
-  const mergeableStore = {
-    getMergeableContent,
-    getMergeableContentHashes,
-    getMergeableTableHashes,
-    getMergeableTableDiff,
-    getMergeableRowHashes,
-    getMergeableRowDiff,
-    getMergeableCellHashes,
-    getMergeableCellDiff,
-    getMergeableValueHashes,
-    getMergeableValueDiff,
-    setMergeableContent,
-    setDefaultContent,
-    getTransactionMergeableChanges,
-    applyMergeableChanges,
-    merge,
+  const delListener = (listenerId) => {
+    delLinkedRowIdsCache(...(delListenerImpl(listenerId) ?? []));
+    return relationships;
   };
-  store.setInternalListeners(
-    preStartTransaction,
-    preFinishTransaction,
-    postFinishTransaction,
-    cellChanged,
-    valueChanged,
-  );
-  objMap(
-    store,
-    (method, name) =>
-      (mergeableStore[name] = // fluent methods
-        strStartsWith(name, SET) ||
-        strStartsWith(name, DEL) ||
-        strStartsWith(name, 'apply') ||
-        strEndsWith(name, TRANSACTION) ||
-        name == 'call' + LISTENER
-          ? (...args) => {
-              method(...args);
-              return mergeableStore;
-            }
-          : strStartsWith(name, ADD) && strEndsWith(name, LISTENER)
-            ? (...args) => {
-                const listenerArg = LISTENER_ARGS[slice(name, 3, -8)] ?? 0;
-                const listener = args[listenerArg];
-                args[listenerArg] = (_store, ...args2) =>
-                  listener(mergeableStore, ...args2);
-                return method(...args);
-              }
-            : name == 'isMergeable'
-              ? () => true
-              : method),
-  );
-  return objFreeze(mergeableStore);
-};
+  const getListenerStats = () => ({
+    remoteRowId: collSize3(remoteRowIdListeners),
+    localRowIds: collSize3(localRowIdsListeners),
+    linkedRowIds: collSize3(linkedRowIdsListeners),
+  });
+  const relationships = {
+    setRelationshipDefinition,
+    delRelationshipDefinition,
+    getStore,
+    getRelationshipIds,
+    forEachRelationship,
+    hasRelationship,
+    getLocalTableId,
+    getRemoteTableId,
+    getRemoteRowId,
+    getLocalRowIds,
+    getLinkedRowIds,
+    addRelationshipIdsListener,
+    addRemoteRowIdListener,
+    addLocalRowIdsListener,
+    addLinkedRowIdsListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(relationships);
+});
 
 export {
   createCheckpoints,