tinybase 5.4.0-beta.1 → 5.4.0-beta.3

package/es6/synchronizers/synchronizer-ws-server-durable-object/with-schemas/index.js

@@ -0,0 +1,1073 @@
+import {DurableObject} from 'cloudflare:workers';
+
+const EMPTY_STRING = '';
+const UNDEFINED = '\uFFFC';
+const strMatch = (str, regex) => (str == null ? void 0 : str.match(regex));
+const strSplit = (str, separator = EMPTY_STRING, limit) =>
+  str.split(separator, limit);
+
+const promise = Promise;
+const GLOBAL = globalThis;
+const THOUSAND = 1e3;
+const startTimeout = (callback, sec = 0) =>
+  setTimeout(callback, sec * THOUSAND);
+const math = Math;
+const mathFloor = math.floor;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? (otherwise == null ? void 0 : otherwise()) : then(value);
+const isArray = (thing) => Array.isArray(thing);
+const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+const size = (arrayOrString) => arrayOrString.length;
+const test = (regex, subject) => regex.test(subject);
+const promiseNew = (resolver) => new promise(resolver);
+const errorNew = (message) => {
+  throw new Error(message);
+};
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayIsEmpty = (array) => size(array) == 0;
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arrayClear = (array, to) => array.splice(0, to);
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isUndefined(obj) &&
+  ifNotUndefined(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isUndefined(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objHas = (obj, id) => id in obj;
+const objForEach = (obj, cb) =>
+  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+const objValues = (obj) => object.values(obj);
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+const objEnsure = (obj, id, getDefaultValue) => {
+  if (!objHas(obj, id)) {
+    obj[id] = getDefaultValue();
+  }
+  return obj[id];
+};
+
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithUndefined = (obj) =>
+  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+const jsonParseWithUndefined = (str) =>
+  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
+
+const MESSAGE_SEPARATOR = '\n';
+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 createPayload = (toClientId, ...args) =>
+  createRawPayload(
+    toClientId != null ? toClientId : EMPTY_STRING,
+    jsonStringWithUndefined(args),
+  );
+const createRawPayload = (clientId, remainder) =>
+  clientId + MESSAGE_SEPARATOR + remainder;
+
+const collSize = (coll) => {
+  var _a;
+  return (_a = coll == null ? void 0 : coll.size) != null ? _a : 0;
+};
+const collHas = (coll, keyOrValue) => {
+  var _a;
+  return (_a = coll == null ? void 0 : coll.has(keyOrValue)) != null
+    ? _a
+    : false;
+};
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collForEach = (coll, cb) => (coll == null ? void 0 : coll.forEach(cb));
+const collDel = (coll, keyOrValue) =>
+  coll == null ? void 0 : coll.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => (map == null ? void 0 : map.get(key));
+const mapSet = (map, key, value) =>
+  isUndefined(value)
+    ? (collDel(map, key), map)
+    : map == null
+      ? void 0
+      : map.set(key, value);
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue == null ? void 0 : hadExistingValue(mapGet(map, key));
+  }
+  return mapGet(map, key);
+};
+const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+  ifNotUndefined(
+    (ensureLeaf ? mapEnsure : mapGet)(
+      node,
+      path[p],
+      p > size(path) - 2 ? ensureLeaf : mapNew,
+    ),
+    (nodeOrLeaf) => {
+      if (p > size(path) - 2) {
+        if (pruneLeaf == null ? void 0 : pruneLeaf(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return nodeOrLeaf;
+      }
+      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+      if (collIsEmpty(nodeOrLeaf)) {
+        mapSet(node, path[p]);
+      }
+      return leaf;
+    },
+  );
+
+const stampNew = (value, time) => (time ? [value, time] : [value]);
+const getLatestTime = (time1, time2) => {
+  var _a;
+  return (
+    /* istanbul ignore next */
+    (_a =
+      (time1 != null ? time1 : '') > (time2 != null ? time2 : '')
+        ? time1
+        : time2) != null
+      ? _a
+      : ''
+  );
+};
+const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
+
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => (set == null ? void 0 : set.add(value));
+
+const INTEGER = /^\d+$/;
+const getPoolFunctions = () => {
+  const pool = [];
+  let nextId = 0;
+  return [
+    (reuse) => {
+      var _a;
+      return (_a = reuse ? arrayShift(pool) : null) != null
+        ? _a
+        : EMPTY_STRING + nextId++;
+    },
+    (id) => {
+      if (test(INTEGER, id) && size(pool) < 1e3) {
+        arrayPush(pool, id);
+      }
+    },
+  ];
+};
+
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const leaves = [];
+  const deep = (node, p) =>
+    p == size(path)
+      ? arrayPush(leaves, node)
+      : path[p] === null
+        ? collForEach(node, (node2) => deep(node2, p + 1))
+        : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
+  deep(deepIdSet, 0);
+  return leaves;
+};
+const getListenerFunctions = (getThing) => {
+  let thing;
+  const [getId, releaseId] = getPoolFunctions();
+  const allListeners = mapNew();
+  const addListener = (
+    listener,
+    idSetNode,
+    path,
+    pathGetters = [],
+    extraArgsGetter = () => [],
+  ) => {
+    thing != null ? thing : (thing = getThing());
+    const id = getId(1);
+    mapSet(allListeners, id, [
+      listener,
+      idSetNode,
+      path,
+      pathGetters,
+      extraArgsGetter,
+    ]);
+    setAdd(
+      visitTree(idSetNode, path != null ? path : [EMPTY_STRING], setNew),
+      id,
+    );
+    return id;
+  };
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) =>
+        mapGet(allListeners, id)[0](
+          thing,
+          ...(ids != null ? ids : []),
+          ...extraArgs,
+        ),
+      ),
+    );
+  const delListener = (id) =>
+    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+      visitTree(
+        idSetNode,
+        idOrNulls != null ? idOrNulls : [EMPTY_STRING],
+        void 0,
+        (idSet) => {
+          collDel(idSet, id);
+          return collIsEmpty(idSet) ? 1 : 0;
+        },
+      );
+      mapSet(allListeners, id);
+      releaseId(id);
+      return idOrNulls;
+    });
+  const callListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([listener, , path = [], pathGetters, extraArgsGetter]) => {
+        const callWithIds = (...ids) => {
+          var _a, _b;
+          const index = size(ids);
+          if (index == size(path)) {
+            listener(thing, ...ids, ...extraArgsGetter(ids));
+          } else if (isUndefined(path[index])) {
+            arrayForEach(
+              (_b =
+                (_a = pathGetters[index]) == null
+                  ? void 0
+                  : _a.call(pathGetters, ...ids)) != null
+                ? _b
+                : [],
+              (id2) => callWithIds(...ids, id2),
+            );
+          } else {
+            callWithIds(...ids, path[index]);
+          }
+        };
+        callWithIds();
+      },
+    );
+  return [addListener, callListeners, delListener, callListener];
+};
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) =>
+  key in obj
+    ? __defProp$1(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value,
+      })
+    : (obj[key] = value);
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop)) __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop)) __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) =>
+      x.done
+        ? resolve(x.value)
+        : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const getStoreFunctions = (
+  persist = 1 /* StoreOnly */,
+  store,
+  isSynchronizer,
+) =>
+  persist != 1 /* StoreOnly */ && store.isMergeable()
+    ? [
+        1,
+        store.getMergeableContent,
+        () => store.getTransactionMergeableChanges(!isSynchronizer),
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : persist != 2 /* MergeableStoreOnly */
+      ? [
+          0,
+          store.getContent,
+          store.getTransactionChanges,
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : errorNew('Store type not supported by this Persister');
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  persist,
+  extra = {},
+  isSynchronizer = 0,
+  scheduleId = [],
+) => {
+  let status = 0; /* Idle */
+  let loads = 0;
+  let saves = 0;
+  let action;
+  let autoLoadHandle;
+  let autoSaveListenerId;
+  mapEnsure(scheduleRunning, scheduleId, () => 0);
+  mapEnsure(scheduleActions, scheduleId, () => []);
+  const statusListeners = mapNew();
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(persist, store, isSynchronizer);
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => persister,
+  );
+  const setStatus = (newStatus) => {
+    if (newStatus != status) {
+      status = newStatus;
+      callListeners(statusListeners, void 0, status);
+    }
+  };
+  const run = () =>
+    __async$2(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (!mapGet(scheduleRunning, scheduleId)) {
+        mapSet(scheduleRunning, scheduleId, 1);
+        while (
+          !isUndefined(
+            (action = arrayShift(mapGet(scheduleActions, scheduleId))),
+          )
+        ) {
+          try {
+            yield action();
+          } catch (error) {}
+        }
+        mapSet(scheduleRunning, scheduleId, 0);
+      }
+    });
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore &&
+      isArray(contentOrChanges == null ? void 0 : contentOrChanges[0])
+      ? (contentOrChanges == null ? void 0 : contentOrChanges[2]) === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : (contentOrChanges == null ? void 0 : contentOrChanges[2]) === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = (initialContent) =>
+    __async$2(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (status != 2 /* Saving */) {
+        setStatus(1 /* Loading */);
+        loads++;
+        yield schedule(() =>
+          __async$2(void 0, null, function* () {
+            try {
+              const content = yield getPersisted();
+              if (isArray(content)) {
+                setContentOrChanges(content);
+              } else if (initialContent) {
+                setDefaultContent(initialContent);
+              } else {
+                errorNew(`Content is not an array: ${content}`);
+              }
+            } catch (error) {
+              if (initialContent) {
+                setDefaultContent(initialContent);
+              }
+            }
+            setStatus(0 /* Idle */);
+          }),
+        );
+      }
+      return persister;
+    });
+  const startAutoLoad = (initialContent) =>
+    __async$2(void 0, null, function* () {
+      stopAutoLoad();
+      yield load(initialContent);
+      try {
+        autoLoadHandle = yield addPersisterListener((content, changes) =>
+          __async$2(void 0, null, function* () {
+            if (changes || content) {
+              /* istanbul ignore else */
+              if (status != 2 /* Saving */) {
+                setStatus(1 /* Loading */);
+                loads++;
+                setContentOrChanges(changes != null ? changes : content);
+                setStatus(0 /* Idle */);
+              }
+            } else {
+              yield load();
+            }
+          }),
+        );
+      } catch (error) {}
+      return persister;
+    });
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = (changes) =>
+    __async$2(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (status != 1 /* Loading */) {
+        setStatus(2 /* Saving */);
+        saves++;
+        yield schedule(() =>
+          __async$2(void 0, null, function* () {
+            try {
+              yield setPersisted(getContent, changes);
+            } catch (error) {}
+            setStatus(0 /* Idle */);
+          }),
+        );
+      }
+      return persister;
+    });
+  const startAutoSave = () =>
+    __async$2(void 0, null, function* () {
+      stopAutoSave();
+      yield save();
+      autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+        const changes = getChanges();
+        if (hasChanges(changes)) {
+          save(changes);
+        }
+      });
+      return persister;
+    });
+  const stopAutoSave = () => {
+    if (autoSaveListenerId) {
+      store.delListener(autoSaveListenerId);
+      autoSaveListenerId = void 0;
+    }
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const getStatus = () => status;
+  const addStatusListener = (listener) =>
+    addListener(listener, statusListeners);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return store;
+  };
+  const schedule = (...actions) =>
+    __async$2(void 0, null, function* () {
+      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+      yield run();
+      return persister;
+    });
+  const getStore = () => store;
+  const destroy = () => {
+    arrayClear(mapGet(scheduleActions, scheduleId));
+    return stopAutoLoad().stopAutoSave();
+  };
+  const getStats = () => ({loads, saves});
+  const persister = __spreadValues$1(
+    {
+      load,
+      startAutoLoad,
+      stopAutoLoad,
+      isAutoLoading,
+      save,
+      startAutoSave,
+      stopAutoSave,
+      isAutoSaving,
+      getStatus,
+      addStatusListener,
+      delListener,
+      schedule,
+      getStore,
+      destroy,
+      getStats,
+    },
+    extra,
+  );
+  return objFreeze(persister);
+};
+
+const MASK6 = 63;
+const ENCODE = /* @__PURE__ */ strSplit(
+  '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz',
+);
+const encode = (num) => ENCODE[num & MASK6];
+
+const getRandomValues = GLOBAL.crypto
+  ? (array) => GLOBAL.crypto.getRandomValues(array)
+  : /* istanbul ignore next */
+    (array) => arrayMap(array, () => mathFloor(math.random() * 256));
+const getUniqueId = (length = 16) =>
+  arrayReduce(
+    getRandomValues(new Uint8Array(length)),
+    (uniqueId, number) => uniqueId + encode(number),
+    '',
+  );
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) =>
+  key in obj
+    ? __defProp(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value,
+      })
+    : (obj[key] = value);
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) =>
+      x.done
+        ? resolve(x.value)
+        : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const createCustomSynchronizer = (
+  store,
+  send,
+  registerReceive,
+  destroyImpl,
+  requestTimeoutSeconds,
+  onSend,
+  onReceive,
+  onIgnoredError,
+  extra = {},
+) => {
+  let syncing = 0;
+  let persisterListener;
+  let sends = 0;
+  let receives = 0;
+  const pendingRequests = mapNew();
+  const getTransactionId = () => getUniqueId(11);
+  const sendImpl = (toClientId, requestId, message, body) => {
+    sends++;
+    send(toClientId, requestId, message, body);
+  };
+  const request = (toClientId, message, body, transactionId) =>
+    __async$1(void 0, null, function* () {
+      return promiseNew((resolve, reject) => {
+        const requestId = transactionId + '.' + getUniqueId(4);
+        const timeout = startTimeout(() => {
+          collDel(pendingRequests, requestId);
+          reject(
+            `No response from ${toClientId != null ? toClientId : 'anyone'} to ${requestId}, ` +
+              message,
+          );
+        }, requestTimeoutSeconds);
+        mapSet(pendingRequests, requestId, [
+          toClientId,
+          (response, fromClientId) => {
+            clearTimeout(timeout);
+            collDel(pendingRequests, requestId);
+            resolve([response, fromClientId, transactionId]);
+          },
+        ]);
+        sendImpl(toClientId, requestId, message, body);
+      });
+    });
+  const mergeTablesStamps = (tablesStamp, [tableStamps2, tablesTime2]) => {
+    objForEach(tableStamps2, ([rowStamps2, tableTime2], tableId) => {
+      const tableStamp = objEnsure(tablesStamp[0], tableId, stampNewObj);
+      objForEach(rowStamps2, ([cellStamps2, rowTime2], rowId) => {
+        const rowStamp = objEnsure(tableStamp[0], rowId, stampNewObj);
+        objForEach(
+          cellStamps2,
+          ([cell2, cellTime2], cellId) =>
+            (rowStamp[0][cellId] = stampNew(cell2, cellTime2)),
+        );
+        rowStamp[1] = getLatestTime(rowStamp[1], rowTime2);
+      });
+      tableStamp[1] = getLatestTime(tableStamp[1], tableTime2);
+    });
+    tablesStamp[1] = getLatestTime(tablesStamp[1], tablesTime2);
+  };
+  const getChangesFromOtherStore = (..._0) =>
+    __async$1(
+      void 0,
+      [..._0],
+      function* (
+        otherClientId = null,
+        otherContentHashes,
+        transactionId = getTransactionId(),
+      ) {
+        try {
+          if (isUndefined(otherContentHashes)) {
+            [otherContentHashes, otherClientId, transactionId] = yield request(
+              null,
+              1 /* GetContentHashes */,
+              EMPTY_STRING,
+              transactionId,
+            );
+          }
+          const [otherTablesHash, otherValuesHash] = otherContentHashes;
+          const [tablesHash, valuesHash] = store.getMergeableContentHashes();
+          let tablesChanges = stampNewObj();
+          if (tablesHash != otherTablesHash) {
+            const [newTables, differentTableHashes] = (yield request(
+              otherClientId,
+              4 /* GetTableDiff */,
+              store.getMergeableTableHashes(),
+              transactionId,
+            ))[0];
+            tablesChanges = newTables;
+            if (!objIsEmpty(differentTableHashes)) {
+              const [newRows, differentRowHashes] = (yield request(
+                otherClientId,
+                5 /* GetRowDiff */,
+                store.getMergeableRowHashes(differentTableHashes),
+                transactionId,
+              ))[0];
+              mergeTablesStamps(tablesChanges, newRows);
+              if (!objIsEmpty(differentRowHashes)) {
+                const newCells = (yield request(
+                  otherClientId,
+                  6 /* GetCellDiff */,
+                  store.getMergeableCellHashes(differentRowHashes),
+                  transactionId,
+                ))[0];
+                mergeTablesStamps(tablesChanges, newCells);
+              }
+            }
+          }
+          return [
+            tablesChanges,
+            valuesHash == otherValuesHash
+              ? stampNewObj()
+              : (yield request(
+                  otherClientId,
+                  7 /* GetValueDiff */,
+                  store.getMergeableValueHashes(),
+                  transactionId,
+                ))[0],
+            1,
+          ];
+        } catch (error) {}
+      },
+    );
+  const getPersisted = () =>
+    __async$1(void 0, null, function* () {
+      const changes = yield getChangesFromOtherStore();
+      return changes &&
+        (!objIsEmpty(changes[0][0]) || !objIsEmpty(changes[1][0]))
+        ? changes
+        : void 0;
+    });
+  const setPersisted = (_getContent, changes) =>
+    __async$1(void 0, null, function* () {
+      return changes
+        ? sendImpl(null, getTransactionId(), 3 /* ContentDiff */, changes)
+        : sendImpl(
+            null,
+            getTransactionId(),
+            2 /* ContentHashes */,
+            store.getMergeableContentHashes(),
+          );
+    });
+  const addPersisterListener = (listener) => (persisterListener = listener);
+  const delPersisterListener = () => (persisterListener = void 0);
+  const startSync = (initialContent) =>
+    __async$1(void 0, null, function* () {
+      syncing = 1;
+      return yield (yield persister.startAutoLoad(
+        initialContent,
+      )).startAutoSave();
+    });
+  const stopSync = () => {
+    syncing = 0;
+    return persister.stopAutoLoad().stopAutoSave();
+  };
+  const destroy = () => {
+    return persister.stopSync();
+  };
+  const getSynchronizerStats = () => ({sends, receives});
+  const persister = createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    2,
+    // MergeableStoreOnly
+    __spreadValues({startSync, stopSync, destroy, getSynchronizerStats}, extra),
+    1,
+  );
+  registerReceive((fromClientId, transactionOrRequestId, message, body) => {
+    const isAutoLoading = syncing || persister.isAutoLoading();
+    receives++;
+    if (message == 0 /* Response */) {
+      ifNotUndefined(
+        mapGet(pendingRequests, transactionOrRequestId),
+        ([toClientId, handleResponse]) =>
+          isUndefined(toClientId) || toClientId == fromClientId
+            ? handleResponse(body, fromClientId)
+            : /* istanbul ignore next */
+              0,
+      );
+    } else if (message == 2 /* ContentHashes */ && isAutoLoading) {
+      getChangesFromOtherStore(
+        fromClientId,
+        body,
+        transactionOrRequestId != null ? transactionOrRequestId : void 0,
+      )
+        .then((changes) => {
+          persisterListener == null
+            ? void 0
+            : persisterListener(void 0, changes);
+        })
+        .catch(onIgnoredError);
+    } else if (message == 3 /* ContentDiff */ && isAutoLoading) {
+      persisterListener == null ? void 0 : persisterListener(void 0, body);
+    } else {
+      ifNotUndefined(
+        message == 1 /* GetContentHashes */ &&
+          (syncing || persister.isAutoSaving())
+          ? store.getMergeableContentHashes()
+          : message == 4 /* GetTableDiff */
+            ? store.getMergeableTableDiff(body)
+            : message == 5 /* GetRowDiff */
+              ? store.getMergeableRowDiff(body)
+              : message == 6 /* GetCellDiff */
+                ? store.getMergeableCellDiff(body)
+                : message == 7 /* GetValueDiff */
+                  ? store.getMergeableValueDiff(body)
+                  : void 0,
+        (response) => {
+          sendImpl(
+            fromClientId,
+            transactionOrRequestId,
+            0 /* Response */,
+            response,
+          );
+        },
+      );
+    }
+  });
+  return persister;
+};
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) =>
+  member.has(obj) || __typeError('Cannot ' + msg);
+var __privateGet = (obj, member, getter) => (
+  __accessCheck(obj, member, 'read from private field'),
+  getter ? getter.call(obj) : member.get(obj)
+);
+var __privateAdd = (obj, member, value) =>
+  member.has(obj)
+    ? __typeError('Cannot add the same private member more than once')
+    : member instanceof WeakSet
+      ? member.add(obj)
+      : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (
+  __accessCheck(obj, member, 'write to private field'),
+  member.set(obj, value),
+  value
+);
+var __privateMethod = (obj, member, method) => (
+  __accessCheck(obj, member, 'access private method'), method
+);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) =>
+      x.done
+        ? resolve(x.value)
+        : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var _serverClientSend,
+  _WsServerDurableObject_instances,
+  handleMessage_fn,
+  getClients_fn;
+const PATH_REGEX = /\/([^?]*)/;
+const SERVER_CLIENT_ID = 'S';
+const getPathId = (request) => {
+  var _a, _b;
+  return (_b =
+    (_a = strMatch(new URL(request.url).pathname, PATH_REGEX)) == null
+      ? void 0
+      : _a[1]) != null
+    ? _b
+    : EMPTY_STRING;
+};
+const getClientId = (request) => {
+  var _a;
+  return ((_a = request.headers.get('upgrade')) == null
+    ? void 0
+    : _a.toLowerCase()) == 'websocket'
+    ? request.headers.get('sec-websocket-key')
+    : null;
+};
+const createResponse = (status, webSocket = null, body = null) =>
+  new Response(body, {status, webSocket});
+const createUpgradeRequiredResponse = () =>
+  createResponse(426, null, 'Upgrade required');
+class WsServerDurableObject extends DurableObject {
+  constructor(ctx, env) {
+    super(ctx, env);
+    __privateAdd(this, _WsServerDurableObject_instances);
+    // @ts-expect-error See blockConcurrencyWhile
+    __privateAdd(this, _serverClientSend);
+    this.ctx.blockConcurrencyWhile(() =>
+      __async(this, null, function* () {
+        return yield ifNotUndefined(yield this.createPersister(), (persister) =>
+          __async(this, null, function* () {
+            const synchronizer = createCustomSynchronizer(
+              persister.getStore(),
+              (toClientId, requestId, message, body) =>
+                __privateMethod(
+                  this,
+                  _WsServerDurableObject_instances,
+                  handleMessage_fn,
+                ).call(
+                  this,
+                  SERVER_CLIENT_ID,
+                  createPayload(toClientId, requestId, message, body),
+                ),
+              (receive) =>
+                __privateSet(this, _serverClientSend, (payload) =>
+                  receivePayload(payload, receive),
+                ),
+              () => {},
+              1,
+            );
+            yield persister.load();
+            yield persister.startAutoSave();
+            startTimeout(synchronizer.startSync);
+          }),
+        );
+      }),
+    );
+  }
+  fetch(request) {
+    const pathId = getPathId(request);
+    return ifNotUndefined(
+      getClientId(request),
+      (clientId) => {
+        const [webSocket, client] = objValues(new WebSocketPair());
+        if (
+          arrayIsEmpty(
+            __privateMethod(
+              this,
+              _WsServerDurableObject_instances,
+              getClients_fn,
+            ).call(this),
+          )
+        ) {
+          this.onPathId(pathId, 1);
+        }
+        this.ctx.acceptWebSocket(client, [clientId, pathId]);
+        this.onClientId(pathId, clientId, 1);
+        client.send(createPayload(SERVER_CLIENT_ID, null, 1, EMPTY_STRING));
+        return createResponse(101, webSocket);
+      },
+      createUpgradeRequiredResponse,
+    );
+  }
+  webSocketMessage(client, message) {
+    ifNotUndefined(this.ctx.getTags(client)[0], (clientId) =>
+      __privateMethod(
+        this,
+        _WsServerDurableObject_instances,
+        handleMessage_fn,
+      ).call(this, clientId, message.toString(), client),
+    );
+  }
+  webSocketClose(client) {
+    const [clientId, pathId] = this.ctx.getTags(client);
+    this.onClientId(pathId, clientId, -1);
+    if (
+      size(
+        __privateMethod(
+          this,
+          _WsServerDurableObject_instances,
+          getClients_fn,
+        ).call(this),
+      ) == 1
+    ) {
+      this.onPathId(pathId, -1);
+    }
+  }
+  // --
+  createPersister() {
+    return void 0;
+  }
+  getPathId() {
+    var _a;
+    return (_a = this.ctx.getTags(
+      __privateMethod(
+        this,
+        _WsServerDurableObject_instances,
+        getClients_fn,
+      ).call(this)[0],
+    )) == null
+      ? void 0
+      : _a[1];
+  }
+  getClientIds(_pathId) {
+    return arrayMap(
+      __privateMethod(
+        this,
+        _WsServerDurableObject_instances,
+        getClients_fn,
+      ).call(this),
+      (client) => this.ctx.getTags(client)[0],
+    );
+  }
+  onPathId(_pathId, _addedOrRemoved) {}
+  onClientId(_pathId, _clientId, _addedOrRemoved) {}
+  onMessage(_fromClientId, _toClientId, _remainder) {}
+}
+_serverClientSend = new WeakMap();
+_WsServerDurableObject_instances = new WeakSet();
+// --
+handleMessage_fn = function (fromClientId, message, fromClient) {
+  ifPayloadValid(message.toString(), (toClientId, remainder) => {
+    var _a;
+    const forwardedPayload = createRawPayload(fromClientId, remainder);
+    this.onMessage(fromClientId, toClientId, remainder);
+    if (toClientId == EMPTY_STRING) {
+      if (fromClientId != SERVER_CLIENT_ID) {
+        __privateGet(this, _serverClientSend).call(this, forwardedPayload);
+      }
+      arrayForEach(
+        __privateMethod(
+          this,
+          _WsServerDurableObject_instances,
+          getClients_fn,
+        ).call(this),
+        (otherClient) => {
+          if (otherClient != fromClient) {
+            otherClient.send(forwardedPayload);
+          }
+        },
+      );
+    } else if (toClientId == SERVER_CLIENT_ID) {
+      __privateGet(this, _serverClientSend).call(this, forwardedPayload);
+    } else if (toClientId != fromClientId) {
+      (_a = __privateMethod(
+        this,
+        _WsServerDurableObject_instances,
+        getClients_fn,
+      ).call(this, toClientId)[0]) == null
+        ? void 0
+        : _a.send(forwardedPayload);
+    }
+  });
+};
+getClients_fn = function (tag) {
+  return this.ctx.getWebSockets(tag);
+};
+const getWsServerDurableObjectFetch = (namespace) => (request, env) =>
+  getClientId(request)
+    ? env[namespace]
+        .get(env[namespace].idFromName(getPathId(request)))
+        .fetch(request)
+    : createUpgradeRequiredResponse();
+
+export {WsServerDurableObject, getWsServerDurableObjectFetch};