tinybase 9.4.0-beta.0 → 9.4.0-beta.2

package/omni/with-schemas/index.js

@@ -356,6 +356,7 @@ const ERROR_INDEXED_DB_OPEN = 12;
 const ERROR_HLC = 13;
 const ERROR_SYNC_MESSAGE = 14;
 const ERROR_SYNC_OVERFLOW = 15;
+const ERROR_QUERY_SELECT_ALL_CYCLE = 16;
 const errorNew = (code, details) =>
   new Error(
     TINYBASE +
@@ -4901,11 +4902,35 @@ const createCustomPersister = (
     initialContent,
     startSaveFirst = false,
   ) => {
-    const [call1, call2] = startSaveFirst
-      ? [startAutoSave, startAutoLoad]
-      : [startAutoLoad, startAutoSave];
-    await call1(initialContent);
-    await call2(initialContent);
+    const [call1, call2, stop1, stop2] = startSaveFirst
+      ? [startAutoSave, startAutoLoad, stopAutoSave, stopAutoLoad]
+      : [startAutoLoad, startAutoSave, stopAutoLoad, stopAutoSave];
+    const start1 = call1(initialContent);
+    const generation1 = startSaveFirst
+      ? autoSaveGeneration
+      : autoLoadGeneration;
+    await start1;
+    const start2 = call2(initialContent);
+    const generation2 = startSaveFirst
+      ? autoLoadGeneration
+      : autoSaveGeneration;
+    try {
+      await start2;
+    } catch (error) {
+      if (
+        generation2 ==
+        (startSaveFirst ? autoLoadGeneration : autoSaveGeneration)
+      ) {
+        await tryCatchIgnore(stop2);
+      }
+      if (
+        generation1 ==
+        (startSaveFirst ? autoSaveGeneration : autoLoadGeneration)
+      ) {
+        await tryCatchIgnore(stop1);
+      }
+      throw error;
+    }
     return persister;
   };
   const stopAutoPersisting = async (stopSaveFirst = false) => {
@@ -5787,6 +5812,8 @@ const createTabularPersister = (
 const TABLE_CREATED = 'c';
 const DATA_CHANGED = 'd';
 const EVENT_REGEX = /^([cd]:)(.+)/;
+const SIMPLE_TABLE_NAME = /^[A-Za-z0-9_]+$/;
+const POSTGRES_IDENTIFIER_SIZE = 63;
 const listenerResourcesByThing = mapNew();
 const createCustomPostgreSqlPersister = (
   store,
@@ -5859,17 +5886,30 @@ const createCustomPostgreSqlPersister = (
           );
   const addDataChangedTriggers = (tableName, dataChangedFunction) =>
     promiseAll(
-      arrayMap([INSERT, DELETE$1, UPDATE], (action, newOrOldOrBoth) =>
-        createTrigger(
+      arrayMap([INSERT, DELETE$1, UPDATE], (action, newOrOldOrBoth) => {
+        const legacyTriggerId = arrayJoin(
+          [TINYBASE, DATA_CHANGED, configHash, tableName, action],
+          '_',
+        );
+        return createTrigger(
           OR_REPLACE,
-          escapeIds(TINYBASE, DATA_CHANGED, configHash, tableName, action),
+          test(SIMPLE_TABLE_NAME, tableName) &&
+            size(legacyTriggerId) <= POSTGRES_IDENTIFIER_SIZE
+            ? escapeId(legacyTriggerId)
+            : escapeIds(
+                TINYBASE,
+                DATA_CHANGED,
+                configHash,
+                action,
+                EMPTY_STRING + getHash(tableName),
+              ),
           `AFTER ${action} ON${escapeId(tableName)}FOR EACH ROW WHEN(${when(
             tableName,
             newOrOldOrBoth,
           )})`,
           dataChangedFunction,
-        ),
-      ),
+        );
+      }),
     );
   const dropFunctions = async (functionNames) => {
     if (!isEmpty(functionNames)) {
@@ -6490,15 +6530,27 @@ const stampNewObjectWithHash$1 = () =>
   stampNewWithHash(objNew(), EMPTY_STRING, 0);
 const escapeGeneratedId = (id) =>
   test(/^[a-zA-Z_][a-zA-Z0-9_]*$/, id) ? id : escapeId(id);
+const encodeStoragePrefix = (storagePrefix) =>
+  arrayJoin(
+    arrayMap(
+      strSplit(storagePrefix),
+      (character) =>
+        '$' + slice((65536 + character.charCodeAt(0)).toString(16), 1),
+    ),
+  );
 const createDurableObjectFragmentedSqlStoragePersister = (
   store,
   sqlStorage,
   storagePrefix = EMPTY_STRING,
   onIgnoredError,
 ) => {
-  const tablePrefix = strReplace(storagePrefix, /[^a-zA-Z0-9_]/g, '_');
-  const tablesTable = escapeGeneratedId(`${tablePrefix}tinybase_tables`);
-  const valuesTable = escapeGeneratedId(`${tablePrefix}tinybase_values`);
+  const tablePrefix = test(/^[a-z0-9_]*$/, storagePrefix)
+    ? storagePrefix
+    : `$tinybase$${encodeStoragePrefix(storagePrefix)}$`;
+  const tablesTableId = `${tablePrefix}tinybase_tables`;
+  const valuesTableId = `${tablePrefix}tinybase_values`;
+  const tablesTable = escapeGeneratedId(tablesTableId);
+  const valuesTable = escapeGeneratedId(valuesTableId);
   const insertTableSql = `INSERT INTO ${tablesTable} (type, table_id, row_id, cell_id, value_data, timestamp, hash) VALUES (?, ?, ?, ?, ?, ?, ?)`;
   const insertValueSql = `INSERT INTO ${valuesTable} (value_id, value_data, timestamp, hash) VALUES (?, ?, ?, ?)`;
   const getRowKey = (tableId, rowId) => jsonString([tableId, rowId]);
@@ -8230,6 +8282,51 @@ const createQueries = getCreateFunction((store) => {
   };
   const preStoreListenerIds = mapNew();
   const sourceStoreListenerIds = mapNew();
+  const selectAllListenerIds = mapNew();
+  const selectAllRetryListenerIds = mapNew();
+  const selectAllQuerySources = mapNew();
+  const referencedQueryIds = mapNew();
+  const assertNoMappedSelectAllCycle = (queryId, nextQuerySources) => {
+    const getQuerySources = (sourceQueryId) =>
+      sourceQueryId === queryId
+        ? nextQuerySources
+        : mapGet(selectAllQuerySources, sourceQueryId);
+    const reachesQuery = (
+      sourceQueryId,
+      targetQueryId,
+      visitedQueryIds = setNew(),
+    ) => {
+      if (sourceQueryId === targetQueryId) {
+        return true;
+      }
+      if (collHas(visitedQueryIds, sourceQueryId)) {
+        return false;
+      }
+      setAdd(visitedQueryIds, sourceQueryId);
+      return !collEvery(
+        getQuerySources(sourceQueryId),
+        (_changesCellId, nextQueryId) =>
+          !reachesQuery(nextQueryId, targetQueryId, visitedQueryIds),
+      );
+    };
+    const hasMappedCycle = (sourceQueryId, querySources) =>
+      !collEvery(
+        querySources,
+        (changesCellId, nextQueryId) =>
+          !changesCellId || !reachesQuery(nextQueryId, sourceQueryId),
+      );
+    if (
+      hasMappedCycle(queryId, nextQuerySources) ||
+      !collEvery(
+        selectAllQuerySources,
+        (querySources, sourceQueryId) =>
+          sourceQueryId === queryId ||
+          !hasMappedCycle(sourceQueryId, querySources),
+      )
+    ) {
+      errorThrow(ERROR_QUERY_SELECT_ALL_CYCLE);
+    }
+  };
   const {
     _: [, addListener, callListeners],
     delListener: delListenerImpl,
@@ -8303,11 +8400,72 @@ const createQueries = getCreateFunction((store) => {
     resetStoreListeners(mapGet(sourceStoreListenerIds, queryId));
     mapSet(sourceStoreListenerIds, queryId);
   };
-  const isResultStoreReferenced = (resultStore2) =>
+  const clearSelectAllRetryListeners = (queryId) =>
+    ifNotUndefined(
+      mapGet(selectAllRetryListenerIds, queryId),
+      (listenerIds) => {
+        mapForEach(listenerIds, (sourceStore, listenerIdsByTableId) =>
+          mapForEach(listenerIdsByTableId, (_sourceTableId, listenerId) =>
+            sourceStore.delListener(listenerId),
+          ),
+        );
+        mapSet(selectAllRetryListenerIds, queryId);
+      },
+    );
+  const addSelectAllRetryListener = (queryId, sourceStore, sourceTableId) => {
+    const listenerIdsByTableId = mapEnsure(
+      mapEnsure(selectAllRetryListenerIds, queryId, mapNew),
+      sourceStore,
+      mapNew,
+    );
+    mapEnsure(listenerIdsByTableId, sourceTableId, () =>
+      sourceStore.addTableListener(sourceTableId, () =>
+        setQueryDefinitionImpl(queryId),
+      ),
+    );
+  };
+  const syncSelectAllListeners = (queryId, nextSources = mapNew()) => {
+    const listenerIds = mapEnsure(selectAllListenerIds, queryId, mapNew);
+    mapForEach(listenerIds, (sourceStore, listenerIdsByTableId) => {
+      mapForEach(listenerIdsByTableId, (sourceTableId, listenerId) =>
+        collHas(mapGet(nextSources, sourceStore), sourceTableId)
+          ? 0
+          : (sourceStore.delListener(listenerId),
+            mapSet(listenerIdsByTableId, sourceTableId)),
+      );
+      if (collIsEmpty(listenerIdsByTableId)) {
+        mapSet(listenerIds, sourceStore);
+      }
+    });
+    mapForEach(nextSources, (sourceStore, tableIds) => {
+      const listenerIdsByTableId = mapEnsure(listenerIds, sourceStore, mapNew);
+      collForEach(tableIds, (sourceTableId) =>
+        mapEnsure(listenerIdsByTableId, sourceTableId, () =>
+          sourceStore.addTableCellIdsListener(sourceTableId, () =>
+            tryCatchSync(
+              () => setQueryDefinitionImpl(queryId),
+              (error) => {
+                addSelectAllRetryListener(queryId, sourceStore, sourceTableId);
+                throw error;
+              },
+            ),
+          ),
+        ),
+      );
+    });
+    if (collIsEmpty(listenerIds)) {
+      mapSet(selectAllListenerIds, queryId);
+    }
+  };
+  const isResultStoreReferenced = (queryId, resultStore2) =>
     !(
       collEvery(routedResultListeners, ([, storeListenerIds]) =>
         collEvery(storeListenerIds, ([store2]) => store2 !== resultStore2),
       ) &&
+      collEvery(
+        referencedQueryIds,
+        (queryIds) => !collHas(queryIds, queryId),
+      ) &&
       arrayEvery(
         [preStoreListenerIds, sourceStoreListenerIds],
         (storeListenerIds) =>
@@ -8322,7 +8480,7 @@ const createQueries = getCreateFunction((store) => {
       hasQuery(queryId) ? 0 : mapSet(preStores, queryId),
     );
     mapForEach(resultStores, (queryId, resultStore2) =>
-      hasQuery(queryId) || isResultStoreReferenced(resultStore2)
+      hasQuery(queryId) || isResultStoreReferenced(queryId, resultStore2)
         ? 0
         : mapSet(resultStores, queryId),
     );
@@ -8404,7 +8562,13 @@ const createQueries = getCreateFunction((store) => {
         const rootStore = asQuery ? getResultStore(tableId) : store;
         const resultStore2 = getResultStore(queryId);
         const paramValues = definition?.[3] ?? getParamValues(queryId);
-        const selectEntries = [];
+        const nextReferencedQueryIds = stagedDefinition[4];
+        if (asQuery) {
+          setAdd(nextReferencedQueryIds, tableId);
+        }
+        const selectionEntries = [];
+        let hasSelectAll = false;
+        let selectCount = 0;
         const joinEntries = [
           [void 0, [tableId, void 0, void 0, [], mapNew(), rootStore]],
         ];
@@ -8416,21 +8580,39 @@ const createQueries = getCreateFunction((store) => {
           const joinedTableId = isTrue(arg1) ? arg2 : arg1;
           const joinedCellId = isTrue(arg1) ? arg3 : arg2;
           const selectEntry = isFunction(arg1)
-            ? [size(selectEntries) + EMPTY_STRING, arg1]
+            ? [0, selectCount + EMPTY_STRING, arg1]
             : isUndefined(joinedCellId)
-              ? [arg1, (getTableCell) => getTableCell(arg1)]
+              ? [0, arg1, (getTableCell) => getTableCell(arg1)]
               : [
+                  0,
                   joinedCellId,
                   (getTableCell) =>
                     isTrue(arg1)
                       ? getTableCell(true, joinedTableId, joinedCellId)
                       : getTableCell(joinedTableId, joinedCellId),
                 ];
-          arrayPush(selectEntries, selectEntry);
+          selectCount++;
+          arrayPush(selectionEntries, selectEntry);
           return {
-            as: (selectedCellId) => (selectEntry[0] = selectedCellId),
+            as: (selectedCellId) => (selectEntry[1] = selectedCellId),
           };
         };
+        const selectAll = (arg1, arg2, arg3) => {
+          hasSelectAll = true;
+          const joinedTableId = isTrue(arg1) ? arg2 : arg1;
+          const prefixOrMapper = isTrue(arg1) ? arg3 : arg2;
+          arrayPush(selectionEntries, [
+            1,
+            joinedTableId,
+            isFunction(prefixOrMapper)
+              ? prefixOrMapper
+              : (cellId) => (prefixOrMapper ?? EMPTY_STRING) + cellId,
+            isFunction(prefixOrMapper) ||
+            (!isUndefined(prefixOrMapper) && prefixOrMapper !== EMPTY_STRING)
+              ? 1
+              : 0,
+          ]);
+        };
         const join = (arg1, arg2, arg3, arg4) => {
           const joinedTableId = isTrue(arg1) ? arg2 : arg1;
           const [fromJoinAlias, onArg] = isTrue(arg1)
@@ -8440,6 +8622,13 @@ const createQueries = getCreateFunction((store) => {
             : isUndefined(arg3) || isFunction(arg2)
               ? [void 0, arg2]
               : [arg2, arg3];
+          const sourceIsQuery = isTrue(arg1);
+          const sourceStore = sourceIsQuery
+            ? getResultStore(joinedTableId)
+            : store;
+          if (sourceIsQuery) {
+            setAdd(nextReferencedQueryIds, joinedTableId);
+          }
           const joinEntry = [
             joinedTableId,
             [
@@ -8448,7 +8637,7 @@ const createQueries = getCreateFunction((store) => {
               isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
               [],
               mapNew(),
-              isTrue(arg1) ? getResultStore(joinedTableId) : store,
+              sourceStore,
             ],
           ];
           arrayPush(joinEntries, joinEntry);
@@ -8494,21 +8683,86 @@ const createQueries = getCreateFunction((store) => {
               : (getSelectedOrGroupedCell) =>
                   getSelectedOrGroupedCell(arg1) === arg2,
           );
-        build({select, join, where, group, having, param});
-        resultStore2.delTable(queryId);
-        const selects = mapNew(selectEntries);
-        if (collIsEmpty(selects)) {
-          commit?.();
-          return queries;
-        }
+        build({select, selectAll, join, where, group, having, param});
         const joins = mapNew(joinEntries);
         mapForEach(joins, (joinAlias, [, fromJoinAlias]) =>
           ifNotUndefined(mapGet(joins, fromJoinAlias), ({3: toJoinAliases2}) =>
             isUndefined(joinAlias) ? 0 : arrayPush(toJoinAliases2, joinAlias),
           ),
         );
+        const isRootSelectAll = (joinedTableId) => isUndefined(joinedTableId);
+        const getSelectAllJoin = (joinedTableId) =>
+          mapGet(
+            joins,
+            isRootSelectAll(joinedTableId) ? void 0 : joinedTableId,
+          );
+        const nextSelectAllQuerySources = stagedDefinition[5];
+        arrayForEach(
+          selectionEntries,
+          ([selectAll2, selectedOrJoinedTableId, , changesCellId = 0]) =>
+            selectAll2
+              ? ifNotUndefined(
+                  getSelectAllJoin(selectedOrJoinedTableId),
+                  ([sourceQueryId, , , , , sourceStore]) =>
+                    sourceStore === store
+                      ? 0
+                      : mapSet(
+                          nextSelectAllQuerySources,
+                          sourceQueryId,
+                          mapGet(nextSelectAllQuerySources, sourceQueryId) ||
+                            changesCellId
+                            ? 1
+                            : 0,
+                        ),
+                )
+              : 0,
+        );
+        assertNoMappedSelectAllCycle(queryId, nextSelectAllQuerySources);
+        resultStore2.delTable(queryId);
+        if (isEmpty(selectionEntries)) {
+          commit?.();
+          return queries;
+        }
         const groups = mapNew(groupEntries);
         const hasGroupsOrHavings = !collIsEmpty(groups) || !isEmpty(havings);
+        const selectEntries = [];
+        const selectAllSources = stagedDefinition[3];
+        arrayForEach(
+          selectionEntries,
+          ([selectAll2, selectedOrJoinedTableId, clauseOrMapper]) => {
+            if (selectAll2) {
+              if (hasGroupsOrHavings) {
+                ifNotUndefined(
+                  getSelectAllJoin(selectedOrJoinedTableId),
+                  ([realTableId, , , , , sourceStore]) => {
+                    setAdd(
+                      mapEnsure(selectAllSources, sourceStore, setNew),
+                      realTableId,
+                    );
+                    arrayForEach(
+                      arraySort(sourceStore.getTableCellIds(realTableId)),
+                      (cellId) =>
+                        arrayPush(selectEntries, [
+                          clauseOrMapper(cellId),
+                          getUndefined,
+                        ]),
+                    );
+                  },
+                );
+              }
+            } else {
+              arrayPush(selectEntries, [
+                selectedOrJoinedTableId,
+                clauseOrMapper,
+              ]);
+            }
+          },
+        );
+        const selects = mapNew(selectEntries);
+        if (hasGroupsOrHavings && collIsEmpty(selects)) {
+          commit?.();
+          return queries;
+        }
         const selectJoinWhereStore = hasGroupsOrHavings
           ? (stagedDefinition[2] = createStore())
           : resultStore2;
@@ -8687,18 +8941,85 @@ const createQueries = getCreateFunction((store) => {
                   joinedCellId,
                 );
           };
-          selectJoinWhereStore.transaction(() =>
-            arrayEvery(wheres, (where2) => where2(getJoinCell))
-              ? mapForEach(selects, (asCellId, tableCellGetter) =>
+          const writeSelectAllRow = () => {
+            const resultRow = objNew();
+            arrayForEach(
+              selectionEntries,
+              ([selectAll2, selectedOrJoinedTableId, clauseOrMapper]) => {
+                if (selectAll2) {
+                  ifNotUndefined(
+                    getSelectAllJoin(selectedOrJoinedTableId),
+                    ([realTableId, , , , remoteIdPairs, sourceStore]) => {
+                      const sourceRowId = isRootSelectAll(
+                        selectedOrJoinedTableId,
+                      )
+                        ? rootRowId
+                        : mapGet(remoteIdPairs, rootRowId)?.[0];
+                      ifNotUndefined(sourceRowId, (sourceRowId2) =>
+                        arrayForEach(
+                          arraySort(
+                            sourceStore.getCellIds(realTableId, sourceRowId2),
+                          ),
+                          (cellId) =>
+                            objSet(
+                              resultRow,
+                              clauseOrMapper(cellId),
+                              sourceStore.getCell(
+                                realTableId,
+                                sourceRowId2,
+                                cellId,
+                              ),
+                            ),
+                        ),
+                      );
+                    },
+                  );
+                } else {
+                  const selectedCell = clauseOrMapper(getJoinCell, rootRowId);
+                  const selectedCellId = selectedOrJoinedTableId;
+                  if (isUndefined(selectedCell)) {
+                    objDel(resultRow, selectedCellId);
+                  } else {
+                    objSet(resultRow, selectedCellId, selectedCell);
+                  }
+                }
+              },
+            );
+            if (objIsEmpty(resultRow)) {
+              selectJoinWhereStore.delRow(queryId, rootRowId);
+            } else {
+              selectJoinWhereStore.setRow(queryId, rootRowId, resultRow);
+            }
+          };
+          selectJoinWhereStore.transaction(() => {
+            if (!arrayEvery(wheres, (where2) => where2(getJoinCell))) {
+              selectJoinWhereStore.delRow(queryId, rootRowId);
+            } else if (hasGroupsOrHavings) {
+              if (hasSelectAll) {
+                writeSelectAllRow();
+              } else {
+                mapForEach(selects, (asCellId, tableCellGetter) =>
                   selectJoinWhereStore._[5](
                     queryId,
                     rootRowId,
                     asCellId,
                     tableCellGetter(getJoinCell, rootRowId),
                   ),
-                )
-              : selectJoinWhereStore.delRow(queryId, rootRowId),
-          );
+                );
+              }
+            } else if (hasSelectAll) {
+              writeSelectAllRow();
+            } else {
+              mapForEach(selects, (asCellId, tableCellGetter) =>
+                selectJoinWhereStore._[5](
+                  queryId,
+                  rootRowId,
+                  asCellId,
+                  tableCellGetter(getJoinCell, rootRowId),
+                ),
+              );
+            }
+          });
         };
         const listenToTable = (
           rootRowId,
@@ -8817,7 +9138,14 @@ const createQueries = getCreateFunction((store) => {
       }),
     );
   const setQueryDefinitionImpl = (queryId, definition) => {
-    const stagedDefinition = [mapNew(), mapNew()];
+    const stagedDefinition = [
+      mapNew(),
+      mapNew(),
+      void 0,
+      mapNew(),
+      setNew(),
+      mapNew(),
+    ];
     let committed = false;
     tryCatchSync(
       () =>
@@ -8838,6 +9166,18 @@ const createQueries = getCreateFunction((store) => {
             collIsEmpty(stagedDefinition[1]) ? void 0 : stagedDefinition[1],
           );
           mapSet(preStores, queryId, stagedDefinition[2]);
+          syncSelectAllListeners(queryId, stagedDefinition[3]);
+          clearSelectAllRetryListeners(queryId);
+          mapSet(
+            referencedQueryIds,
+            queryId,
+            collIsEmpty(stagedDefinition[4]) ? void 0 : stagedDefinition[4],
+          );
+          mapSet(
+            selectAllQuerySources,
+            queryId,
+            collIsEmpty(stagedDefinition[5]) ? void 0 : stagedDefinition[5],
+          );
           committed = true;
         }),
       (error) => {
@@ -8887,6 +9227,10 @@ const createQueries = getCreateFunction((store) => {
     paramStore.delRow(PARAMS_TABLE, queryId);
     resetPreStores(queryId);
     resetSourceStores(queryId);
+    syncSelectAllListeners(queryId);
+    clearSelectAllRetryListeners(queryId);
+    mapSet(referencedQueryIds, queryId);
+    mapSet(selectAllQuerySources, queryId);
     delDefinition(queryId);
     cleanStores();
     return queries;
@@ -9221,6 +9565,9 @@ const FRAGMENT_PAYLOAD = /^[^\n]*\n[-0-9A-Z_a-z]{16}\n\d+\n\d+\n/;
 const INVALID_CHANNEL_ID_CHARACTERS = /[\n\r?#]/;
 const MAX_FRAGMENT_BUFFERS = 100;
 const MAX_FRAGMENT_COUNT = 1e3;
+const MAX_MULTIPLE_CHANNELS = 100;
+const MAX_MULTIPLE_CHANNEL_RESOURCES = MAX_MULTIPLE_CHANNELS * 2;
+const MAX_MULTIPLE_CHANNEL_ID_SIZE = 1024;
 const MAX_PENDING_REQUESTS = 100;
 const MAX_WEBSOCKET_BUFFER_SIZE = 16777216;
 const MAX_WEBSOCKET_QUEUE_SIZE = 1e3;
@@ -9359,21 +9706,30 @@ const createPayloadDecoder = (
   receive,
   fragmentTimeoutSeconds = 1,
   onInvalid,
+  sharedBuffer,
 ) => {
   const buffer = mapNew();
+  const payloadBuffer = sharedBuffer ?? [0, 0];
   let bufferedSize = 0;
   let valid = true;
   const delPending = (bufferKey, pending) => {
     stopTimeout(pending[4]);
     bufferedSize -= pending[5];
+    payloadBuffer[0]--;
+    payloadBuffer[1] -= pending[5];
     collDel(buffer, bufferKey);
   };
+  const clear = () => {
+    mapForEach(buffer, (_bufferKey, pending) => stopTimeout(pending[4]));
+    payloadBuffer[0] -= collSize(buffer);
+    payloadBuffer[1] -= bufferedSize;
+    collClear(buffer);
+    bufferedSize = 0;
+  };
   const invalid = (error = errorNew(ERROR_SYNC_MESSAGE)) => {
     if (valid) {
       valid = false;
-      mapForEach(buffer, (_bufferKey, pending) => stopTimeout(pending[4]));
-      collClear(buffer);
-      bufferedSize = 0;
+      clear();
       onInvalid?.(error);
     }
   };
@@ -9385,7 +9741,7 @@ const createPayloadDecoder = (
       invalid();
     }
   };
-  return (payload) => {
+  const decode = (payload) => {
     if (!valid) {
       return;
     }
@@ -9418,42 +9774,52 @@ const createPayloadDecoder = (
             const bufferKey = clientId + MESSAGE_SEPARATOR + messageId;
             let pending = mapGet(buffer, bufferKey);
             if (!pending) {
-              if (collSize(buffer) >= MAX_FRAGMENT_BUFFERS) {
+              if (payloadBuffer[0] >= MAX_FRAGMENT_BUFFERS) {
                 invalid(errorNew(ERROR_SYNC_OVERFLOW, 'fragments'));
                 return;
               }
-              pending = [
-                [],
-                [],
-                total,
-                total,
-                startTimeout(() => {
-                  const timedOut = mapGet(buffer, bufferKey);
-                  if (timedOut) {
-                    delPending(bufferKey, timedOut);
-                  }
-                }, fragmentTimeoutSeconds),
-                0,
-              ];
-              mapSet(buffer, bufferKey, pending);
             }
-            const [fragments, remainders] = pending;
-            if (total == pending[3] && isUndefined(fragments[index])) {
-              const fragmentLength = getWebSocketPayloadSize(fragment);
-              if (bufferedSize + fragmentLength > MAX_WEBSOCKET_BUFFER_SIZE) {
+            if (
+              (isUndefined(pending) || total == pending[3]) &&
+              isUndefined(pending?.[0][index])
+            ) {
+              const retainedSize =
+                getWebSocketPayloadSize(remainder) +
+                (pending ? 0 : getWebSocketPayloadSize(bufferKey));
+              if (payloadBuffer[1] + retainedSize > MAX_WEBSOCKET_BUFFER_SIZE) {
                 invalid(errorNew(ERROR_SYNC_OVERFLOW, 'fragments'));
                 return;
               }
+              if (!pending) {
+                pending = [
+                  [],
+                  [],
+                  total,
+                  total,
+                  startTimeout(() => {
+                    const timedOut = mapGet(buffer, bufferKey);
+                    if (timedOut) {
+                      delPending(bufferKey, timedOut);
+                    }
+                  }, fragmentTimeoutSeconds),
+                  0,
+                ];
+                mapSet(buffer, bufferKey, pending);
+                payloadBuffer[0]++;
+              }
+              const [fragments, remainders] = pending;
               fragments[index] = fragment;
               remainders[index] = remainder;
               pending[2]--;
-              pending[5] += fragmentLength;
-              bufferedSize += fragmentLength;
+              pending[5] += retainedSize;
+              bufferedSize += retainedSize;
+              payloadBuffer[1] += retainedSize;
             } else {
               invalid();
               return;
             }
             if (pending[2] == 0) {
+              const [fragments, remainders] = pending;
               delPending(bufferKey, pending);
               receiveRemainder(clientId, remainders, arrayJoin(fragments));
             }
@@ -9466,6 +9832,7 @@ const createPayloadDecoder = (
       invalid();
     }
   };
+  return [decode, clear];
 };
 const getPayloadCoalesceKey = (clientId, payload) => {
   let key;
@@ -9482,12 +9849,14 @@ const createPayloadReceiver = (
   receive,
   fragmentTimeoutSeconds = 1,
   onInvalid,
+  sharedBuffer,
 ) =>
   createPayloadDecoder(
     (fromClientId, _remainders, requestId, message, body) =>
       receive(fromClientId, requestId, message, body),
     fragmentTimeoutSeconds,
     onInvalid,
+    sharedBuffer,
   );
 const createPayload = (toClientId, ...args) =>
   createRawPayload(toClientId, jsonStringWithUndefined(args));
@@ -9522,12 +9891,15 @@ const getFragments = (remainder, maxFragmentSize) => {
 };
 const createMultiplePayload = (channelId, payload) =>
   createRawPayload(MULTIPLE_CLIENT_ID, createRawPayload(channelId, payload));
-const ifMultiplePayloadValid = (payload, then) => {
+const ifMultiplePayloadValid = (payload, then, onOversized) => {
   let valid = false;
   ifPayloadValid(payload, (multipleClientId, remainder) => {
     if (multipleClientId == MULTIPLE_CLIENT_ID) {
       ifPayloadValid(remainder, (channelId, channelPayload) => {
-        if (isMultipleChannelIdValid(channelId)) {
+        if (isMultipleChannelIdTooLarge(channelId)) {
+          valid = true;
+          onOversized?.();
+        } else if (isMultipleChannelIdStructureValid(channelId)) {
           valid = true;
           then(channelId, channelPayload);
         }
@@ -9541,6 +9913,15 @@ const createMultipleControlPayload = (requestId, control, body) =>
     SERVER_CLIENT_ID$1,
     jsonStringWithUndefined([requestId, MULTIPLE_MESSAGE, [control, body]]),
   );
+const isMultipleChannelIdTooLarge = (channelId) =>
+  getWebSocketPayloadSize(channelId) > MAX_MULTIPLE_CHANNEL_ID_SIZE;
+const isMultipleChannelIdStructureValid = (channelId) =>
+  !isEmpty(channelId) &&
+  !INVALID_CHANNEL_ID_CHARACTERS.test(channelId) &&
+  arrayEvery(
+    strSplit(channelId, '/'),
+    (part) => !isEmpty(part) && part != '.' && part != '..',
+  );
 const ifMultipleControlPayloadValid = (payload, then) => {
   let valid = false;
   ifPayloadValid(payload, (serverClientId, remainder) => {
@@ -9558,11 +9939,13 @@ const ifMultipleControlPayloadValid = (payload, then) => {
           : control == 1 /* Subscribe */
             ? isString(requestId) &&
               isString(body) &&
-              isMultipleChannelIdValid(body)
+              (isMultipleChannelIdTooLarge(body) ||
+                isMultipleChannelIdStructureValid(body))
             : control == 2 /* Unsubscribe */ &&
               isNull(requestId) &&
               isString(body) &&
-              isMultipleChannelIdValid(body))
+              (isMultipleChannelIdTooLarge(body) ||
+                isMultipleChannelIdStructureValid(body)))
       ) {
         valid = true;
         then(requestId, control, body);
@@ -9572,12 +9955,8 @@ const ifMultipleControlPayloadValid = (payload, then) => {
   return valid;
 };
 const isMultipleChannelIdValid = (channelId) =>
-  !isEmpty(channelId) &&
-  !INVALID_CHANNEL_ID_CHARACTERS.test(channelId) &&
-  arrayEvery(
-    strSplit(channelId, '/'),
-    (part) => !isEmpty(part) && part != '.' && part != '..',
-  );
+  !isMultipleChannelIdTooLarge(channelId) &&
+  isMultipleChannelIdStructureValid(channelId);
 const createMultipleServerClient = (
   basePathId,
   addChannel,
@@ -9590,26 +9969,87 @@ const createMultipleServerClient = (
 ) => {
   const channels = mapNew();
   const decoders = mapNew();
+  const payloadBuffer = [0, 0];
+  const resources = setNew();
+  let resourceCount = 0;
   let negotiated = false;
+  let valid = true;
   const sendControl = (requestId, control, body) =>
     send(createMultipleControlPayload(requestId, control, body));
   const delChannelAndDecoder = (channelId) => {
     collDel(channels, channelId);
+    mapGet(decoders, channelId)?.[1]();
     collDel(decoders, channelId);
   };
+  const clearDecoders = () => {
+    mapForEach(decoders, (_channelId, decoder) => decoder[1]());
+    collClear(decoders);
+  };
+  const invalidate = (error) => {
+    if (valid) {
+      valid = false;
+      clearDecoders();
+      invalid(error);
+    }
+  };
+  const releaseChannel = (channel) => {
+    if (!channel[2 /* Released */]) {
+      channel[2 /* Released */] = 1;
+      resourceCount--;
+      collDel(resources, channel);
+    }
+  };
+  const teardownChannel = (channel) =>
+    (channel[1 /* Teardown */] ??= (async () => {
+      try {
+        const teardown = delChannel(channel[0 /* Channel */]);
+        if (isUndefined(teardown)) {
+          releaseChannel(channel);
+        } else {
+          await teardown;
+        }
+      } finally {
+        releaseChannel(channel);
+      }
+    })());
   const handleControl = (requestId, control, body) => {
     if (control == 0 /* Hello */) {
       negotiated = true;
       sendControl(requestId, control, body);
     } else if (negotiated && control == 1 /* Subscribe */) {
-      if (!collHas(channels, body)) {
+      const subscribed = collHas(channels, body);
+      if (
+        isMultipleChannelIdTooLarge(body) ||
+        (!subscribed &&
+          (collSize(channels) >= MAX_MULTIPLE_CHANNELS ||
+            resourceCount >= MAX_MULTIPLE_CHANNEL_RESOURCES))
+      ) {
+        invalidate(errorNew(ERROR_SYNC_OVERFLOW, 'channels'));
+        return;
+      }
+      if (!subscribed) {
         const pathId = basePathId + (basePathId ? '/' : EMPTY_STRING) + body;
-        const [channel, ready] = addChannel(pathId, body);
+        resourceCount++;
+        let channelAndReady;
+        try {
+          channelAndReady = addChannel(pathId, body);
+        } catch (error) {
+          resourceCount--;
+          throw error;
+        }
+        const [addedChannel, ready] = channelAndReady;
+        const channel = [addedChannel];
+        setAdd(resources, channel);
         mapSet(channels, body, channel);
         sendControl(requestId, control, body);
         if (ready) {
           return ready.catch((error) => {
-            delChannelAndDecoder(body);
+            if (mapGet(channels, body) === channel) {
+              delChannelAndDecoder(body);
+            }
+            if (!channel[1 /* Teardown */]) {
+              releaseChannel(channel);
+            }
             throw error;
           });
         }
@@ -9617,16 +10057,21 @@ const createMultipleServerClient = (
       }
       sendControl(requestId, control, body);
     } else if (negotiated && control == 2 /* Unsubscribe */) {
+      if (isMultipleChannelIdTooLarge(body)) {
+        invalidate(errorNew(ERROR_SYNC_OVERFLOW, 'channels'));
+        return;
+      }
       const channel = mapGet(channels, body);
       delChannelAndDecoder(body);
-      if (!isUndefined(channel)) {
-        return (async () => delChannel(channel))();
-      }
+      return isUndefined(channel) ? void 0 : teardownChannel(channel);
     }
   };
   const handlePayload = (payload) => {
+    if (!valid) {
+      return;
+    }
     if (isWebSocketPayloadTooLarge(getWebSocketPayloadSize(payload))) {
-      invalid(errorNew(ERROR_SYNC_OVERFLOW, 'socket'));
+      invalidate(errorNew(ERROR_SYNC_OVERFLOW, 'socket'));
       return;
     }
     const control = ifMultipleControlPayloadValid(
@@ -9641,32 +10086,54 @@ const createMultipleServerClient = (
       (channelId, channelPayload) => {
         const channel2 = negotiated ? mapGet(channels, channelId) : void 0;
         if (isUndefined(channel2)) {
-          invalid(errorNew(ERROR_SYNC_MESSAGE));
+          invalidate(errorNew(ERROR_SYNC_MESSAGE));
         } else {
           mapEnsure(decoders, channelId, () =>
             createPayloadDecoder(
               (toClientId, remainders) =>
-                receive(channel2, toClientId, remainders),
+                receive(channel2[0 /* Channel */], toClientId, remainders),
               fragmentTimeoutSeconds,
-              invalid,
+              invalidate,
+              payloadBuffer,
             ),
-          )(channelPayload);
+          )[0](channelPayload);
         }
       },
+      () => invalidate(errorNew(ERROR_SYNC_OVERFLOW, 'channels')),
     );
     if (!control && !channel) {
-      invalid(errorNew(ERROR_SYNC_MESSAGE));
+      invalidate(errorNew(ERROR_SYNC_MESSAGE));
     }
   };
-  const destroy = () =>
-    tryFinallyAsync(
-      () =>
-        promiseAll(mapMap(channels, async (channel) => delChannel(channel))),
+  const destroy = () => {
+    valid = false;
+    clearDecoders();
+    return tryFinallyAsync(
+      async () => {
+        let errorToThrow;
+        let failed = false;
+        await promiseAll(
+          arrayMap(collValues(resources), async (channel) => {
+            try {
+              await teardownChannel(channel);
+            } catch (error) {
+              if (!failed) {
+                errorToThrow = error;
+                failed = true;
+              }
+            }
+          }),
+        );
+        if (failed) {
+          throw errorToThrow;
+        }
+      },
       () => {
         collClear(channels);
-        collClear(decoders);
+        clearDecoders();
       },
     );
+  };
   return [handlePayload, destroy];
 };
 const createPayloads = (toClientId, requestId, message, body, fragmentSize) => {
@@ -10063,6 +10530,7 @@ const createConnection = () => {
 const createMultipleState = (webSocket) => {
   const channels = mapNew();
   const pendingControls = mapNew();
+  const payloadBuffer = [0, 0];
   const removeListeners = [];
   let connection = createConnection();
   let connected = false;
@@ -10074,6 +10542,7 @@ const createMultipleState = (webSocket) => {
   let overflowing = false;
   let queuedCount = 0;
   let queuedSize = 0;
+  let receiving = true;
   const notifyChannelIgnoredError = (channel, error) =>
     tryReturn(() => channel[6 /* OnIgnoredError */]?.(error));
   const notifyIgnoredError = (error) =>
@@ -10085,11 +10554,10 @@ const createMultipleState = (webSocket) => {
     disconnect();
     tryReturn(() => webSocket.close());
   };
-  const invalid = createInvalidPayloadHandler(webSocket, notifyIgnoredError);
   const addWebSocketListener = (event, handler) =>
     arrayPush(removeListeners, addEventListener(webSocket, event, handler));
   const rejectPendingControls = (error) =>
-    mapForEach(pendingControls, (requestId, [, , reject, timeout]) => {
+    mapForEach(pendingControls, (requestId, [, , , reject, timeout]) => {
       stopTimeout(timeout);
       collDel(pendingControls, requestId);
       reject(error);
@@ -10120,11 +10588,43 @@ const createMultipleState = (webSocket) => {
       channel[7 /* Dirty */] = void 0;
     }
   };
+  const clearReceive = (channel) => channel[0 /* Receive */]?.[1]();
+  const clearReceives = () =>
+    mapForEach(channels, (_channelId, channel) => clearReceive(channel));
+  const handleInvalid = createInvalidPayloadHandler(
+    webSocket,
+    notifyIgnoredError,
+  );
+  const invalid = (error) => {
+    if (receiving) {
+      receiving = false;
+      disconnected = true;
+      connected = false;
+      clearReceives();
+      connection[2](error);
+      rejectPendingControls(error);
+      failChannels(error);
+      mapForEach(channels, (_channelId, channel) => {
+        clearIncoming(channel);
+        clearOutgoing(channel, true);
+        channel[3 /* Subscribed */] = false;
+        channel[4 /* Subscribing */] = void 0;
+        channel[12 /* SubscribeConnection */] = void 0;
+      });
+      if (flushTimeout) {
+        stopTimeout(flushTimeout);
+        flushTimeout = void 0;
+      }
+      handleInvalid(error);
+    }
+  };
   const overflow = (details) => {
     const error = errorNew(ERROR_SYNC_OVERFLOW, details);
     if (!overflowing && !destroyed) {
       overflowing = true;
+      receiving = false;
       connected = false;
+      clearReceives();
       notifyIgnoredError(error);
       rejectPendingControls(error);
       failChannels(error);
@@ -10133,6 +10633,7 @@ const createMultipleState = (webSocket) => {
         clearOutgoing(channel, true);
         channel[3 /* Subscribed */] = false;
         channel[4 /* Subscribing */] = void 0;
+        channel[12 /* SubscribeConnection */] = void 0;
       });
       if (flushTimeout) {
         stopTimeout(flushTimeout);
@@ -10154,7 +10655,7 @@ const createMultipleState = (webSocket) => {
     });
     return timeoutSeconds;
   };
-  const sendControl = (control, body, timeoutSeconds) => {
+  const sendControl = (control, body, timeoutSeconds, onSent) => {
     const requestId = getUniqueId();
     return promiseNew((resolve, reject) => {
       if (collSize(pendingControls) >= MAX_PENDING_REQUESTS) {
@@ -10174,9 +10675,16 @@ const createMultipleState = (webSocket) => {
         collDel(pendingControls, requestId);
         reject(errorNew(ERROR_MULTIPLEX_RESPONSE, control));
       }, timeoutSeconds);
-      mapSet(pendingControls, requestId, [control, resolve, reject, timeout]);
+      mapSet(pendingControls, requestId, [
+        control,
+        body,
+        resolve,
+        reject,
+        timeout,
+      ]);
       try {
         webSocket.send(payload);
+        onSent?.();
       } catch (error) {
         stopTimeout(timeout);
         collDel(pendingControls, requestId);
@@ -10359,23 +10867,45 @@ const createMultipleState = (webSocket) => {
   const subscribe = async (channelId, channel, timeoutSeconds) => {
     if (!channel[3 /* Subscribed */]) {
       let subscribing = channel[4 /* Subscribing */];
-      if (!subscribing) {
-        subscribing = (async () => {
-          await connection[0];
+      const subscribingConnection = connection;
+      if (subscribing?.[0] !== subscribingConnection) {
+        const subscribingPromise = (async () => {
+          await subscribingConnection[0];
+          if (
+            mapGet(channels, channelId) !== channel ||
+            connection !== subscribingConnection ||
+            !connected
+          ) {
+            return;
+          }
           await sendControl(
             MultipleControl.Subscribe,
             channelId,
             timeoutSeconds,
+            () => {
+              if (
+                mapGet(channels, channelId) === channel &&
+                connection === subscribingConnection &&
+                connected
+              ) {
+                channel[12 /* SubscribeConnection */] = subscribingConnection;
+              }
+            },
           );
-          if (mapGet(channels, channelId) === channel && connected) {
+          if (
+            mapGet(channels, channelId) === channel &&
+            connection === subscribingConnection &&
+            connected
+          ) {
             channel[3 /* Subscribed */] = true;
             flushOutgoing(channelId, channel);
           }
         })();
+        subscribing = [subscribingConnection, subscribingPromise];
         channel[4 /* Subscribing */] = subscribing;
       }
       try {
-        await subscribing;
+        await subscribing[1];
       } finally {
         if (channel[4 /* Subscribing */] === subscribing) {
           channel[4 /* Subscribing */] = void 0;
@@ -10384,7 +10914,7 @@ const createMultipleState = (webSocket) => {
     }
   };
   const onOpen = () => {
-    if (destroyed || opening?.[0] === connection) {
+    if (destroyed || !receiving || connected || opening?.[0] === connection) {
       return;
     }
     disconnected = false;
@@ -10397,7 +10927,7 @@ const createMultipleState = (webSocket) => {
           MULTIPLE_VERSION,
           getConnectionTimeoutSeconds(),
         );
-        if (connection === openingConnection) {
+        if (connection === openingConnection && receiving && !destroyed) {
           connected = true;
           openingConnection[1]();
           mapForEach(channels, (channelId, channel) =>
@@ -10445,13 +10975,18 @@ const createMultipleState = (webSocket) => {
       }
       connection = createConnection();
       mapForEach(channels, (_channelId, channel) => {
+        clearReceive(channel);
         channel[3 /* Subscribed */] = false;
         channel[4 /* Subscribing */] = void 0;
+        channel[12 /* SubscribeConnection */] = void 0;
       });
     }
   };
   const onClose = disconnect;
   addWebSocketListener(MESSAGE, ({data}) => {
+    if (!receiving) {
+      return;
+    }
     const payload = data.toString(UTF8);
     if (isWebSocketPayloadTooLarge(getWebSocketPayloadSize(payload))) {
       invalid(errorNew(ERROR_SYNC_OVERFLOW, 'socket'));
@@ -10459,14 +10994,23 @@ const createMultipleState = (webSocket) => {
     }
     const control = ifMultipleControlPayloadValid(
       payload,
-      (requestId, control2, _body) => {
+      (requestId, control2, body) => {
+        if (
+          (control2 == MultipleControl.Subscribe ||
+            control2 == MultipleControl.Unsubscribe) &&
+          isString(body) &&
+          !isMultipleChannelIdValid(body)
+        ) {
+          overflow('channels');
+          return;
+        }
         const pendingControl = requestId
           ? mapGet(pendingControls, requestId)
           : void 0;
-        if (pendingControl?.[0] == control2) {
-          stopTimeout(pendingControl[3]);
+        if (pendingControl?.[0] == control2 && pendingControl[1] === body) {
+          stopTimeout(pendingControl[4]);
           collDel(pendingControls, requestId);
-          pendingControl[1]();
+          pendingControl[2]();
         }
       },
     );
@@ -10476,7 +11020,7 @@ const createMultipleState = (webSocket) => {
         const channel2 = mapGet(channels, channelId);
         if (channel2) {
           if (channel2[0 /* Receive */]) {
-            channel2[0 /* Receive */](channelPayload);
+            channel2[0 /* Receive */][0](channelPayload);
           } else {
             queueIncoming(channel2, channelPayload);
           }
@@ -10484,6 +11028,7 @@ const createMultipleState = (webSocket) => {
           invalid(errorNew(ERROR_SYNC_MESSAGE));
         }
       },
+      () => overflow('channels'),
     );
     if (!control && !channel) {
       invalid(errorNew(ERROR_SYNC_MESSAGE));
@@ -10496,12 +11041,18 @@ const createMultipleState = (webSocket) => {
     failChannels(errorNew(ERROR_MULTIPLEX_SOCKET));
   });
   const addChannel = async (channelId, timeoutSeconds, onIgnoredError) => {
+    if (!receiving || destroyed) {
+      errorThrow(ERROR_MULTIPLEX_SOCKET);
+    }
     if (!isMultipleChannelIdValid(channelId)) {
       errorThrow(ERROR_MULTIPLEX_CHANNEL, channelId);
     }
     if (collHas(channels, channelId)) {
       errorThrow(ERROR_MULTIPLEX_CHANNEL_DUPLICATE, channelId);
     }
+    if (collSize(channels) >= MAX_MULTIPLE_CHANNELS) {
+      errorThrow(ERROR_SYNC_OVERFLOW, 'channels');
+    }
     const channel = [
       void 0,
       [],
@@ -10515,6 +11066,7 @@ const createMultipleState = (webSocket) => {
       0,
       0,
       void 0,
+      void 0,
     ];
     mapSet(channels, channelId, channel);
     if (webSocket.readyState == webSocket.OPEN) {
@@ -10548,7 +11100,7 @@ const createMultipleState = (webSocket) => {
             queuedCount--;
             queuedSize -= payloadSize;
             incomingIndex++;
-            receive(payload);
+            receive[0](payload);
           }
         },
         () => arrayClear(incoming, incomingIndex),
@@ -10556,6 +11108,9 @@ const createMultipleState = (webSocket) => {
     }
   };
   const send = (channelId, payloads, coalesce) => {
+    if (!receiving) {
+      return;
+    }
     const channel = mapGet(channels, channelId);
     if (channel) {
       if (
@@ -10576,6 +11131,9 @@ const createMultipleState = (webSocket) => {
   const destroyIfEmpty = () => {
     if (collIsEmpty(channels) && !destroyed) {
       destroyed = true;
+      const closeWebSocket = receiving && !overflowing;
+      receiving = false;
+      clearReceives();
       const error = errorNew(ERROR_MULTIPLEX_DESTROYED);
       rejectPendingControls(error);
       if (flushTimeout) {
@@ -10587,7 +11145,7 @@ const createMultipleState = (webSocket) => {
       );
       arrayClear(removeListeners);
       multipleStates.delete(webSocket);
-      if (!overflowing) {
+      if (closeWebSocket) {
         tryReturn(() => webSocket.close());
       }
     }
@@ -10596,9 +11154,10 @@ const createMultipleState = (webSocket) => {
     const channel = mapGet(channels, channelId);
     if (channel) {
       try {
+        clearReceive(channel);
         clearIncoming(channel);
         clearOutgoing(channel, true);
-        if (connected && channel[3 /* Subscribed */]) {
+        if (connected && channel[12 /* SubscribeConnection */] === connection) {
           const payload = createMultipleControlPayload(
             null,
             MultipleControl.Unsubscribe,
@@ -10627,6 +11186,7 @@ const createMultipleState = (webSocket) => {
     delChannel,
     destroyIfEmpty,
     invalid,
+    payloadBuffer,
     registerReceive,
     send,
   };
@@ -10682,7 +11242,12 @@ const createMultipleWsSynchronizer = async (
       (receive, fail) =>
         state.registerReceive(
           channelId,
-          createPayloadReceiver(receive, requestTimeoutSeconds, state.invalid),
+          createPayloadReceiver(
+            receive,
+            requestTimeoutSeconds,
+            state.invalid,
+            state.payloadBuffer,
+          ),
           fail,
         ),
       () => state.delChannel(channelId),
@@ -10724,13 +11289,14 @@ const createLegacyWsSynchronizer = async (
   };
   const registerReceive = (receive, fail) => {
     const invalid = createInvalidPayloadHandler(webSocket, notifyIgnoredError);
-    const receivePayload = createPayloadReceiver(
+    const [receivePayload, clearReceivePayload] = createPayloadReceiver(
       receive,
       requestTimeoutSeconds,
       invalid,
     );
     let removeListeners = [];
     removeTransportListeners = () => {
+      clearReceivePayload();
       arrayForEach(removeListeners, (removeListener) =>
         tryReturn(removeListener),
       );
@@ -10900,7 +11466,7 @@ class WsServerDurableObject extends DurableObject {
                 (this.#serverClientSend = createPayloadReceiver(
                   receive,
                   requestTimeoutSeconds,
-                )),
+                )[0]),
               noop,
               requestTimeoutSeconds,
             );
@@ -10948,10 +11514,11 @@ class WsServerDurableObject extends DurableObject {
         );
         this.#payloadDecoders.set(client, decode);
       }
-      decode(message.toString());
+      decode[0](message.toString());
     });
   }
   webSocketClose(client) {
+    this.#payloadDecoders.get(client)?.[1]();
     this.#payloadDecoders.delete(client);
     const [clientId, pathId] = this.ctx.getTags(client);
     this.onClientId(pathId, clientId, -1);
@@ -11104,7 +11671,7 @@ const createWsServerSimple = (webSocketServer) => {
   };
   const addLegacyClient = (client, clientId, pathId) => {
     addClientToPath(pathId, clientId, [client]);
-    const decode = createPayloadDecoder(
+    const [decode, clearDecoder] = createPayloadDecoder(
       (toClientId, remainders) =>
         handleDecodedMessage(pathId, clientId, toClientId, remainders),
       1,
@@ -11113,8 +11680,10 @@ const createWsServerSimple = (webSocketServer) => {
     addWebSocketListener(client, MESSAGE, (data) =>
       decode(data.toString(UTF8)),
     );
-    mapGet(webSocketStates, client)[1] = () =>
+    mapGet(webSocketStates, client)[1] = () => {
+      clearDecoder();
       delClientFromPath(pathId, clientId);
+    };
   };
   const addMultipleClient = (client, clientId, basePathId) => {
     const invalid = createInvalidPayloadHandler(client);
@@ -11244,6 +11813,7 @@ const createWsServer = (
   const clientIdListeners = mapNew();
   const paths = mapNew();
   const webSockets = setNew();
+  const buffersByWebSocket = mapNew();
   const removeServerListeners = [];
   const removeListenersByWebSocket = mapNew();
   let destroying;
@@ -11293,7 +11863,7 @@ const createWsServer = (
         serverClient[3 /* Send */] = createPayloadReceiver(
           receive,
           requestTimeoutSeconds,
-        );
+        )[0];
       },
       noop,
       requestTimeoutSeconds,
@@ -11357,18 +11927,37 @@ const createWsServer = (
       client.send(outgoingPayload);
     }
   };
+  const updateWebSocketBuffer = (webSocket, count, size2) => {
+    const webSocketBuffer = mapEnsure(buffersByWebSocket, webSocket, () => [
+      0, 0,
+    ]);
+    webSocketBuffer[0] += count;
+    webSocketBuffer[1] += size2;
+    if (!webSocketBuffer[0]) {
+      mapSet(buffersByWebSocket, webSocket);
+    }
+  };
+  const delBufferedFromWebSocket = ([, payload, , webSocket]) =>
+    updateWebSocketBuffer(webSocket, -1, -getWebSocketPayloadSize(payload));
   const clearServerBuffer = (serverClient) => {
     if (serverClient[7 /* BufferTimeout */]) {
       stopTimeout(serverClient[7 /* BufferTimeout */]);
       serverClient[7 /* BufferTimeout */] = void 0;
     }
+    arrayForEach(serverClient[4 /* Buffer */], delBufferedFromWebSocket);
     serverClient[4 /* Buffer */] = [];
     serverClient[6 /* BufferSize */] = 0;
   };
   const delBufferedClient = (serverClient, clientId) => {
     serverClient[4 /* Buffer */] = arrayFilter(
       serverClient[4 /* Buffer */],
-      ([bufferedClientId]) => bufferedClientId != clientId,
+      (buffered) => {
+        if (buffered[0] == clientId) {
+          delBufferedFromWebSocket(buffered);
+          return false;
+        }
+        return true;
+      },
     );
     serverClient[6 /* BufferSize */] = arrayReduce(
       serverClient[4 /* Buffer */],
@@ -11382,10 +11971,8 @@ const createWsServer = (
   const expireServerBuffer = (path) => {
     const serverClient = path[1 /* ServerClient */];
     const clients = setNew();
-    arrayForEach(serverClient[4 /* Buffer */], ([clientId]) =>
-      ifNotUndefined(mapGet(path[0 /* Clients */], clientId), ([client]) =>
-        setAdd(clients, client),
-      ),
+    arrayForEach(serverClient[4 /* Buffer */], ([, , , client]) =>
+      setAdd(clients, client),
     );
     clearServerBuffer(serverClient);
     arrayForEach(collValues(clients), (client) =>
@@ -11395,6 +11982,10 @@ const createWsServer = (
   const bufferMessage = (path, clientId, payload) => {
     const serverClient = path[1 /* ServerClient */];
     const buffer = serverClient[4 /* Buffer */];
+    const webSocket = mapGet(path[0 /* Clients */], clientId)?.[0];
+    if (isUndefined(webSocket)) {
+      return;
+    }
     const coalesceKey = getPayloadCoalesceKey(clientId, payload);
     const coalesceIndex = coalesceKey
       ? arrayFindIndex(
@@ -11402,14 +11993,22 @@ const createWsServer = (
           ([, , bufferedKey]) => bufferedKey == coalesceKey,
         )
       : -1;
-    const replacedSize =
-      coalesceIndex > -1
-        ? getWebSocketPayloadSize(buffer[coalesceIndex][1])
-        : 0;
+    const replaced = coalesceIndex > -1 ? buffer[coalesceIndex] : void 0;
+    const replacedSize = isUndefined(replaced)
+      ? 0
+      : getWebSocketPayloadSize(replaced[1]);
     const payloadSize = getWebSocketPayloadSize(payload);
+    const webSocketBuffer = mapGet(buffersByWebSocket, webSocket);
+    const sameWebSocket = replaced?.[3] === webSocket;
     if (
       (coalesceIndex < 0 && size(buffer) >= MAX_WEBSOCKET_QUEUE_SIZE) ||
       serverClient[6 /* BufferSize */] + payloadSize - replacedSize >
+        MAX_WEBSOCKET_BUFFER_SIZE ||
+      (!sameWebSocket &&
+        (webSocketBuffer?.[0] ?? 0) >= MAX_WEBSOCKET_QUEUE_SIZE) ||
+      (webSocketBuffer?.[1] ?? 0) +
+        payloadSize -
+        (sameWebSocket ? replacedSize : 0) >
         MAX_WEBSOCKET_BUFFER_SIZE
     ) {
       delBufferedClient(serverClient, clientId);
@@ -11418,12 +12017,14 @@ const createWsServer = (
       );
       return;
     }
-    const buffered = [clientId, payload, coalesceKey];
+    const buffered = [clientId, payload, coalesceKey, webSocket];
     if (coalesceIndex > -1) {
+      delBufferedFromWebSocket(buffer[coalesceIndex]);
       buffer[coalesceIndex] = buffered;
     } else {
       arrayPush(buffer, buffered);
     }
+    updateWebSocketBuffer(webSocket, 1, payloadSize);
     serverClient[6 /* BufferSize */] += payloadSize - replacedSize;
     serverClient[7 /* BufferTimeout */] ??= startTimeout(
       () => expireServerBuffer(path),
@@ -11582,7 +12183,7 @@ const createWsServer = (
   };
   const addLegacyClient = async (client, clientId, pathId) => {
     const [path, ready] = addClientToPath(pathId, clientId, [client]);
-    const decode = createPayloadDecoder(
+    const [decode, clearDecoder] = createPayloadDecoder(
       (toClientId, remainders) =>
         handleDecodedMessage(path, clientId, toClientId, remainders),
       requestTimeoutSeconds,
@@ -11591,9 +12192,10 @@ const createWsServer = (
     addWebSocketListener(client, MESSAGE, (data) =>
       decode(data.toString(UTF8)),
     );
-    addWebSocketListener(client, CLOSE, () =>
-      delClientFromPath(pathId, path, clientId).catch(handleError),
-    );
+    addWebSocketListener(client, CLOSE, () => {
+      clearDecoder();
+      delClientFromPath(pathId, path, clientId).catch(handleError);
+    });
     await ready;
   };
   const addMultipleClient = (client, clientId, basePathId) => {
@@ -11738,6 +12340,7 @@ const createWsServer = (
           arrayForEach(removers, (remove) => tryReturn(remove)),
         );
         collClear(removeListenersByWebSocket);
+        collClear(buffersByWebSocket);
         collClear(paths);
         collClear(webSockets);
         const failure = serverFailure[0]