tinybase 8.6.0-beta.0 → 9.0.0-beta.0

package/omni/index.js

@@ -79,6 +79,7 @@ const startInterval = (callback, sec, immediate) => {
 const stopInterval = clearInterval;
 const startTimeout = (callback, sec = 0) =>
   setTimeout(callback, sec * THOUSAND);
+const stopTimeout = clearTimeout;
 const mathMax = math.max;
 const mathMin = math.min;
 const mathFloor = math.floor;
@@ -378,14 +379,12 @@ const getDefinableFunctions = (
       const newRowValue = hasRow(tableId, rowId)
         ? validateRowValue(getRowValue(getCell, rowId))
         : void 0;
-      if (
-        !(
-          oldRowValue === newRowValue ||
-          (isArray(oldRowValue) &&
-            isArray(newRowValue) &&
-            arrayIsEqual(oldRowValue, newRowValue))
-        )
-      ) {
+      if (!(
+        oldRowValue === newRowValue ||
+        (isArray(oldRowValue) &&
+          isArray(newRowValue) &&
+          arrayIsEqual(oldRowValue, newRowValue))
+      )) {
         mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);
       }
       if (!isUndefined(getSortKey)) {
@@ -4123,6 +4122,8 @@ const DEFAULT_TABULAR_VALUES_CONFIG = {
   save: 0,
   [TABLE_NAME]: TINYBASE + '_values',
 };
+const getValuesIn = (config) => (isArray(config) ? config : void 0);
+const hasValues = (config) => isTrue(config) || isArray(config);
 const getDefaultedConfig = (configOrStoreTableName) =>
   objMerge(
     DEFAULT_CONFIG,
@@ -4173,11 +4174,15 @@ const getConfigStructures = (configOrStoreTableName) => {
     ];
   }
   const {tables: {load = {}, save = {}} = {}, values = {}} = config;
-  const valuesConfig = slice(
-    objValues(objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values)),
-    0,
-    objSize(DEFAULT_TABULAR_VALUES_CONFIG),
-  );
+  const valuesConfigObj = objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values);
+  const {load: valuesLoad, save: valuesSave} = valuesConfigObj;
+  const valuesConfig = [
+    hasValues(valuesLoad),
+    hasValues(valuesSave),
+    valuesConfigObj[TABLE_NAME],
+    getValuesIn(valuesLoad),
+    getValuesIn(valuesSave),
+  ];
   const valuesTable = valuesConfig[2];
   const managedTableNames = setNew(valuesTable);
   const excludedTableNames = setNew(valuesTable);
@@ -4239,8 +4244,18 @@ const getCommandFunctions = (
       ({tn, cn}) => setAdd(mapEnsure(schemaMap, tn, setNew), cn),
     );
   };
-  const loadTable = async (tableName, rowIdColumnName, condition) =>
-    canSelect(tableName, rowIdColumnName)
+  const loadTable = async (
+    tableName,
+    rowIdColumnName,
+    condition,
+    contentSubIds,
+  ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
+    return canSelect(tableName, rowIdColumnName)
       ? objNew(
           arrayFilter(
             arrayMap(
@@ -4249,17 +4264,35 @@ const getCommandFunctions = (
                   escapeId(tableName) +
                   getWhereCondition(tableName, condition),
               ),
-              (row) => [
-                row[rowIdColumnName],
-                decode
+              (row) => {
+                const rowId = row[rowIdColumnName];
+                const rowContent = decode
                   ? objMap(objDel(row, rowIdColumnName), decode)
-                  : objDel(row, rowIdColumnName),
-              ],
+                  : objDel(row, rowIdColumnName);
+                return [
+                  rowId,
+                  isUndefined(contentSubIdSet)
+                    ? rowContent
+                    : objNew(
+                        arrayFilter(
+                          objToArray(
+                            rowContent,
+                            (cellOrValue, contentSubId) => [
+                              contentSubId,
+                              cellOrValue,
+                            ],
+                          ),
+                          ([contentSubId]) => includeContentSubId(contentSubId),
+                        ),
+                      ),
+                ];
+              },
             ),
             (entry) => !isUndefined(entry[0]) && !objIsEmpty(entry[1]),
           ),
         )
       : {};
+  };
   const saveTable = async (
     tableName,
     rowIdColumnName,
@@ -4268,15 +4301,23 @@ const getCommandFunctions = (
     deleteEmptyTable,
     partial = false,
     condition = TRUE,
+    contentSubIds,
   ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
     const settingColumnNameSet = setNew();
     objMap(content ?? {}, (contentRow) =>
-      arrayMap(objIds(contentRow ?? {}), (cellOrValueId) =>
-        setAdd(settingColumnNameSet, cellOrValueId),
+      arrayMap(
+        arrayFilter(objIds(contentRow ?? {}), includeContentSubId),
+        (cellOrValueId) => setAdd(settingColumnNameSet, cellOrValueId),
       ),
     );
     const settingColumnNames = collValues(settingColumnNameSet);
     if (
+      isUndefined(contentSubIdSet) &&
       !partial &&
       deleteEmptyTable &&
       condition == TRUE &&
@@ -4288,7 +4329,13 @@ const getCommandFunctions = (
       return;
     }
     const currentColumnNames = mapGet(schemaMap, tableName);
-    const unaccountedColumnNames = setNew(collValues(currentColumnNames));
+    const unaccountedColumnNames = setNew(
+      arrayFilter(
+        collValues(currentColumnNames),
+        (columnName) =>
+          columnName == rowIdColumnName || includeContentSubId(columnName),
+      ),
+    );
     if (!arrayIsEmpty(settingColumnNames)) {
       if (!collHas(schemaMap, tableName)) {
         await databaseExecuteCommand(
@@ -4354,11 +4401,13 @@ const getCommandFunctions = (
     ]);
     if (partial) {
       if (isUndefined(content)) {
-        await databaseExecuteCommand(
-          DELETE_FROM +
-            escapeId(tableName) +
-            getWhereCondition(tableName, condition),
-        );
+        if (isUndefined(contentSubIdSet)) {
+          await databaseExecuteCommand(
+            DELETE_FROM +
+              escapeId(tableName) +
+              getWhereCondition(tableName, condition),
+          );
+        }
       } else {
         await promiseAll(
           objToArray(content, async (row, rowId) => {
@@ -4371,18 +4420,24 @@ const getCommandFunctions = (
                 [rowId],
               );
             } else if (!arrayIsEmpty(settingColumnNames)) {
-              await upsert(
-                databaseExecuteCommand,
-                tableName,
-                rowIdColumnName,
+              const changingColumnNames = arrayFilter(
                 objIds(row),
-                {
-                  [rowId]: encode
-                    ? arrayMap(objValues(row), encode)
-                    : objValues(row),
-                },
-                currentColumnNames,
+                includeContentSubId,
               );
+              if (!arrayIsEmpty(changingColumnNames)) {
+                await upsert(
+                  databaseExecuteCommand,
+                  tableName,
+                  rowIdColumnName,
+                  changingColumnNames,
+                  {
+                    [rowId]: arrayMap(changingColumnNames, (cellId) =>
+                      encode ? encode(row[cellId]) : row[cellId],
+                    ),
+                  },
+                  currentColumnNames,
+                );
+              }
             }
           }),
         );
@@ -4391,7 +4446,9 @@ const getCommandFunctions = (
       if (!arrayIsEmpty(settingColumnNames)) {
         const changingColumnNames = arrayFilter(
           collValues(mapGet(schemaMap, tableName)),
-          (changingColumnName) => changingColumnName != rowIdColumnName,
+          (changingColumnName) =>
+            changingColumnName != rowIdColumnName &&
+            includeContentSubId(changingColumnName),
         );
         const rows = {};
         const deleteRowIds = [];
@@ -4407,6 +4464,7 @@ const getCommandFunctions = (
           rowIdColumnName,
           changingColumnNames,
           rows,
+          currentColumnNames,
         );
         await databaseExecuteCommand(
           DELETE_FROM +
@@ -4415,7 +4473,10 @@ const getCommandFunctions = (
             `AND${escapeId(rowIdColumnName)}NOT IN(${getPlaceholders(deleteRowIds)})`,
           deleteRowIds,
         );
-      } else if (collHas(schemaMap, tableName)) {
+      } else if (
+        isUndefined(contentSubIdSet) &&
+        collHas(schemaMap, tableName)
+      ) {
         await databaseExecuteCommand(
           DELETE_FROM +
             escapeId(tableName) +
@@ -4554,7 +4615,13 @@ const createTabularPersister = (
   [
     tablesLoadConfig,
     tablesSaveConfig,
-    [valuesLoad, valuesSave, valuesTableName],
+    [
+      valuesLoad,
+      valuesSave,
+      valuesTableName,
+      valuesLoadValueIds,
+      valuesSaveValueIds,
+    ],
   ],
   managedTableNames,
   querySchema,
@@ -4604,15 +4671,33 @@ const createTabularPersister = (
         },
       ),
     );
+  const getValuesSubset = (values, valueIds, partial) =>
+    objNew(
+      partial == true
+        ? arrayFilter(
+            objToArray(values, (value, valueId) => [valueId, value]),
+            ([valueId]) => arrayHas(valueIds, valueId),
+          )
+        : arrayFilter(
+            arrayMap(valueIds, (valueId) => [valueId, values[valueId]]),
+            ([, value]) => !isUndefined(value),
+          ),
+    );
   const saveValues = async (values, partial) =>
     valuesSave
       ? await saveTable(
           valuesTableName,
           DEFAULT_ROW_ID_COLUMN_NAME,
-          {[SINGLE_ROW_ID]: values},
+          {
+            [SINGLE_ROW_ID]: isUndefined(valuesSaveValueIds)
+              ? values
+              : getValuesSubset(values, valuesSaveValueIds, partial),
+          },
           true,
           true,
           partial,
+          void 0,
+          valuesSaveValueIds,
         )
       : null;
   const loadTables = async () =>
@@ -4632,9 +4717,14 @@ const createTabularPersister = (
     );
   const loadValues = async () =>
     valuesLoad
-      ? (await loadTable(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
-          SINGLE_ROW_ID
-        ]
+      ? (
+          await loadTable(
+            valuesTableName,
+            DEFAULT_ROW_ID_COLUMN_NAME,
+            void 0,
+            valuesLoadValueIds,
+          )
+        )[SINGLE_ROW_ID]
       : {};
   const getPersisted = () =>
     transaction(async () => {
@@ -5859,83 +5949,57 @@ const createPowerSyncPersister = (
     // StoreOnly,
     powerSync,
     'getPowerSync',
-    viewUpsert,
+    powerSyncUpdateThenInsert,
   );
 };
-const viewUpsert = async (
+const powerSyncUpdateThenInsert = async (
   executeCommand,
   tableName,
   rowIdColumnName,
   changingColumnNames,
   rows,
-  currentColumnNames,
 ) => {
-  const offset = [1];
-  const changingColumnNamesSet = setNew(changingColumnNames);
-  const unchangingColumnNames = currentColumnNames
-    ? arrayFilter(
-        [...currentColumnNames],
-        (currentColumnName) =>
-          currentColumnName != rowIdColumnName &&
-          !collHas(changingColumnNamesSet, currentColumnName),
-      )
-    : [];
-  if (!arrayIsEmpty(unchangingColumnNames)) {
-    const ids = objIds(rows);
-    const unchangingData = objNew(
-      arrayMap(
+  const assignments = arrayJoin(
+    arrayMap(
+      changingColumnNames,
+      (columnName, index) => escapeId(columnName) + '=$' + (index + 1),
+    ),
+    COMMA,
+  );
+  for (const [id, row] of objToArray(rows, (row2, id2) => [id2, row2])) {
+    const rowParams = arrayMap(row, (value) => value ?? null);
+    if (
+      arrayIsEmpty(
         await executeCommand(
-          SELECT +
-            escapeColumnNames(rowIdColumnName, ...unchangingColumnNames) +
-            FROM +
+          UPDATE +
             escapeId(tableName) +
+            ' SET' +
+            assignments +
+            ' ' +
             WHERE +
             escapeId(rowIdColumnName) +
-            'IN(' +
-            getPlaceholders(ids) +
-            ')',
-          ids,
+            '=$' +
+            (row.length + 1) +
+            ' RETURNING' +
+            escapeId(rowIdColumnName),
+          [...rowParams, id],
         ),
-        (unchangingRow) => [unchangingRow[rowIdColumnName], unchangingRow],
-      ),
-    );
-    arrayForEach(ids, (id) =>
-      arrayPush(
-        rows[id],
-        ...arrayMap(
-          unchangingColumnNames,
-          (unchangingColumnName) =>
-            unchangingData?.[id]?.[unchangingColumnName] ?? null,
-        ),
-      ),
-    );
+      )
+    ) {
+      const offset = [1];
+      await executeCommand(
+        INSERT +
+          ' INTO' +
+          escapeId(tableName) +
+          '(' +
+          escapeColumnNames(rowIdColumnName, ...changingColumnNames) +
+          ')VALUES(' +
+          getPlaceholders([id, ...row], offset) +
+          ')',
+        [id, ...rowParams],
+      );
+    }
   }
-  await executeCommand(
-    INSERT +
-      ' ' +
-      OR_REPLACE +
-      'INTO' +
-      escapeId(tableName) +
-      '(' +
-      escapeColumnNames(
-        rowIdColumnName,
-        ...changingColumnNames,
-        ...unchangingColumnNames,
-      ) +
-      ')VALUES' +
-      arrayJoin(
-        objToArray(
-          rows,
-          (row) =>
-            '($' + offset[0]++ + ',' + getPlaceholders(row, offset) + ')',
-        ),
-        COMMA,
-      ),
-    objToArray(rows, (row, id) => [
-      id,
-      ...arrayMap(row, (value) => value ?? null),
-    ]).flat(),
-  );
 };
 
 const STORAGE = 'storage';
@@ -6316,9 +6380,9 @@ const PARAMS_TABLE = '_';
 const PARAM_LISTENER_PREFIX = 'p';
 const createQueries = getCreateFunction((store) => {
   const createStore = store._[0];
-  const preStore = createStore();
   const paramStore = createStore();
   const resultStore = createStore();
+  const preStores = mapNew();
   const resultStores = mapNew();
   const redefiningQueryIds = setNew();
   const routedResultListeners = mapNew();
@@ -6361,12 +6425,13 @@ const createQueries = getCreateFunction((store) => {
   );
   const getResultStore = (queryId) =>
     mapEnsure(resultStores, queryId, createStore);
-  const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
+  const getPreStore = (queryId) => mapEnsure(preStores, queryId, createStore);
+  const addPreStoreListener = (preStore, queryId, ...listenerIds) =>
     arrayForEach(listenerIds, (listenerId) =>
       setAdd(
         mapEnsure(
           mapEnsure(preStoreListenerIds, queryId, mapNew),
-          preStore2,
+          preStore,
           setNew,
         ),
         listenerId,
@@ -6376,16 +6441,17 @@ const createQueries = getCreateFunction((store) => {
     ifNotUndefined(
       mapGet(preStoreListenerIds, queryId),
       (queryPreStoreListenerIds) => {
-        mapForEach(queryPreStoreListenerIds, (preStore2, listenerIds) =>
+        mapForEach(queryPreStoreListenerIds, (preStore, listenerIds) =>
           collForEach(listenerIds, (listenerId) =>
-            preStore2.delListener(listenerId),
+            preStore.delListener(listenerId),
           ),
         );
         collClear(queryPreStoreListenerIds);
       },
     );
-    arrayForEach([getResultStore(queryId), preStore], (store2) =>
-      store2.delTable(queryId),
+    arrayForEach(
+      [getResultStore(queryId), mapGet(preStores, queryId)],
+      (store2) => store2?.delTable(queryId),
     );
   };
   const addSourceStoreListeners = (
@@ -6613,10 +6679,12 @@ const createQueries = getCreateFunction((store) => {
           ),
         );
         const groups = mapNew(groupEntries);
-        let selectJoinWhereStore = preStore;
-        if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
-          selectJoinWhereStore = resultStore2;
-        } else {
+        const hasGroupsOrHavings =
+          !collIsEmpty(groups) || !arrayIsEmpty(havings);
+        const selectJoinWhereStore = hasGroupsOrHavings
+          ? getPreStore(queryId)
+          : resultStore2;
+        if (hasGroupsOrHavings) {
           synchronizeTransactions(queryId, selectJoinWhereStore, resultStore2);
           const groupedSelectedCellIds = mapNew();
           mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
@@ -7529,20 +7597,87 @@ const createLocalSynchronizer = (store, onSend, onReceive, onIgnoredError) => {
 };
 
 const MESSAGE_SEPARATOR = '\n';
+const FRAGMENT = /^(.+)\n(\d+)\n(\d+)\n([\s\S]*)$/;
 const ifPayloadValid = (payload, then) => {
   const splitAt = payload.indexOf(MESSAGE_SEPARATOR);
   if (splitAt !== -1) {
     then(slice(payload, 0, splitAt), slice(payload, splitAt + 1));
   }
 };
-const receivePayload = (payload, receive) =>
-  ifPayloadValid(payload, (fromClientId, remainder) =>
-    receive(fromClientId, ...jsonParseWithUndefined(remainder)),
-  );
+const receivePayloadRemainder = (fromClientId, remainder, receive) =>
+  receive(fromClientId, ...jsonParseWithUndefined(remainder));
+const createPayloadReceiver = (receive, fragmentTimeoutSeconds = 1) => {
+  const buffer = mapNew();
+  const setPendingTimeout = (bufferKey) =>
+    startTimeout(() => collDel(buffer, bufferKey), fragmentTimeoutSeconds);
+  const delPending = (bufferKey, pending) => {
+    stopTimeout(pending[3]);
+    collDel(buffer, bufferKey);
+  };
+  return (payload) =>
+    ifPayloadValid(payload, (fromClientId, remainder) => {
+      const [, messageId, indexStr, totalStr, fragment] =
+        strMatch(remainder, FRAGMENT) ?? [];
+      if (messageId) {
+        const index = parseInt(indexStr);
+        const total = parseInt(totalStr);
+        if (total > 0 && index >= 0 && index < total) {
+          const bufferKey = fromClientId + MESSAGE_SEPARATOR + messageId;
+          const pending = mapEnsure(buffer, bufferKey, () => [
+            [],
+            total,
+            total,
+            setPendingTimeout(bufferKey),
+          ]);
+          const [fragments] = pending;
+          if (total == pending[2] && isUndefined(fragments[index])) {
+            stopTimeout(pending[3]);
+            pending[3] = setPendingTimeout(bufferKey);
+            fragments[index] = fragment;
+            pending[1]--;
+          }
+          if (pending[1] == 0) {
+            delPending(bufferKey, pending);
+            receivePayloadRemainder(
+              fromClientId,
+              arrayJoin(fragments),
+              receive,
+            );
+          }
+        }
+      } else {
+        receivePayloadRemainder(fromClientId, remainder, receive);
+      }
+    });
+};
 const createPayload = (toClientId, ...args) =>
-  createRawPayload(toClientId ?? EMPTY_STRING, jsonStringWithUndefined(args));
+  createRawPayload(toClientId, jsonStringWithUndefined(args));
 const createRawPayload = (clientId, remainder) =>
   clientId + MESSAGE_SEPARATOR + remainder;
+const createPayloads = (toClientId, requestId, message, body, fragmentSize) => {
+  const clientId = toClientId ?? EMPTY_STRING;
+  const remainder = jsonStringWithUndefined([requestId, message, body]);
+  const maxFragmentSize = mathFloor(fragmentSize ?? 0);
+  if (
+    isUndefined(fragmentSize) ||
+    maxFragmentSize < 1 ||
+    size(remainder) <= maxFragmentSize
+  ) {
+    return [createRawPayload(clientId, remainder)];
+  }
+  const fragments = strMatch(
+    remainder,
+    new RegExp(`.{1,${maxFragmentSize}}`, 'g'),
+  );
+  const total = size(fragments ?? []);
+  const messageId = getUniqueId();
+  return arrayMap(fragments ?? [], (fragment, index) =>
+    createRawPayload(
+      clientId,
+      arrayJoin([messageId, index, total, fragment], MESSAGE_SEPARATOR),
+    ),
+  );
+};
 
 const createWsSynchronizer = async (
   store,
@@ -7551,17 +7686,23 @@ const createWsSynchronizer = async (
   onSend,
   onReceive,
   onIgnoredError,
+  fragmentSize,
 ) => {
   const addEventListener = (event, handler) => {
     webSocket.addEventListener(event, handler);
     return () => webSocket.removeEventListener(event, handler);
   };
-  const registerReceive = (receive) =>
-    addEventListener(MESSAGE, ({data}) =>
-      receivePayload(data.toString(UTF8), receive),
+  const registerReceive = (receive) => {
+    const receivePayload = createPayloadReceiver(
+      receive,
+      requestTimeoutSeconds,
     );
+    addEventListener(MESSAGE, ({data}) => receivePayload(data.toString(UTF8)));
+  };
   const send = (toClientId, ...args) =>
-    webSocket.send(createPayload(toClientId, ...args));
+    arrayForEach(createPayloads(toClientId, ...args, fragmentSize), (payload) =>
+      webSocket.send(payload),
+    );
   const destroy = () => {
     webSocket.close();
   };
@@ -7616,18 +7757,27 @@ class WsServerDurableObject extends DurableObject {
         await ifNotUndefined(
           await this.createPersister(),
           async (persister) => {
+            const requestTimeoutSeconds = this.getRequestTimeoutSeconds();
             const synchronizer = createCustomSynchronizer(
               persister.getStore(),
               (toClientId, requestId, message, body) =>
-                this.#handleMessage(
-                  SERVER_CLIENT_ID$1,
-                  createPayload(toClientId, requestId, message, body),
+                arrayForEach(
+                  createPayloads(
+                    toClientId,
+                    requestId,
+                    message,
+                    body,
+                    this.getFragmentSize(),
+                  ),
+                  (payload) => this.#handleMessage(SERVER_CLIENT_ID$1, payload),
                 ),
               (receive) =>
-                (this.#serverClientSend = (payload) =>
-                  receivePayload(payload, receive)),
+                (this.#serverClientSend = createPayloadReceiver(
+                  receive,
+                  requestTimeoutSeconds,
+                )),
               noop,
-              1,
+              requestTimeoutSeconds,
             );
             await persister.load();
             await persister.startAutoSave();
@@ -7702,6 +7852,12 @@ class WsServerDurableObject extends DurableObject {
       (client) => this.ctx.getTags(client)[0],
     );
   }
+  getFragmentSize() {
+    return void 0;
+  }
+  getRequestTimeoutSeconds() {
+    return 1;
+  }
   onPathId(_pathId, _addedOrRemoved) {}
   onClientId(_pathId, _clientId, _addedOrRemoved) {}
   onMessage(_fromClientId, _toClientId, _remainder) {}
@@ -7762,6 +7918,8 @@ const createWsServer = (
   webSocketServer,
   createPersisterForPath,
   onIgnoredError,
+  requestTimeoutSeconds = 1,
+  fragmentSize,
 ) => {
   const pathIdListeners = mapNew();
   const clientIdListeners = mapNew();
@@ -7786,12 +7944,24 @@ const createWsServer = (
         serverClient[2 /* Synchronizer */] = createCustomSynchronizer(
           serverClient[1 /* Persister */].getStore(),
           (toClientId, requestId, message, body) =>
-            messageHandler(createPayload(toClientId, requestId, message, body)),
-          (receive) =>
-            (serverClient[3 /* Send */] = (payload) =>
-              receivePayload(payload, receive)),
+            arrayForEach(
+              createPayloads(
+                toClientId,
+                requestId,
+                message,
+                body,
+                fragmentSize,
+              ),
+              messageHandler,
+            ),
+          (receive) => {
+            serverClient[3 /* Send */] = createPayloadReceiver(
+              receive,
+              requestTimeoutSeconds,
+            );
+          },
           noop,
-          1,
+          requestTimeoutSeconds,
           void 0,
           void 0,
           onIgnoredError,
@@ -7803,14 +7973,14 @@ const createWsServer = (
       },
     );
   const startServerClient = async (serverClient) => {
-    serverClient[0 /* State */] = 2 /* Starting */;
+    serverClient[0 /* State */] = 2; /* Starting */
     await serverClient[1 /* Persister */].schedule(
       serverClient[1 /* Persister */].startAutoLoad,
       serverClient[1 /* Persister */].startAutoSave,
       serverClient[2 /* Synchronizer */].startSync,
     );
     serverClient[5 /* Then */](serverClient[1 /* Persister */].getStore());
-    serverClient[0 /* State */] = 0 /* Ready */;
+    serverClient[0 /* State */] = 0; /* Ready */
   };
   const stopServerClient = async (serverClient) => {
     await serverClient[1 /* Persister */]?.destroy();