@liveblocks/core 0.19.0-beta0 → 0.19.0

package/dist/index.js

@@ -50,7 +50,161 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/assert.ts
+// src/lib/utils.ts
+function isPlainObject(blob) {
+  return blob !== null && typeof blob === "object" && Object.prototype.toString.call(blob) === "[object Object]";
+}
+function fromEntries(iterable) {
+  const obj = {};
+  for (const [key, val] of iterable) {
+    obj[key] = val;
+  }
+  return obj;
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+function tryParseJson(rawMessage) {
+  try {
+    return JSON.parse(rawMessage);
+  } catch (e) {
+    return void 0;
+  }
+}
+function b64decode(b64value) {
+  try {
+    const formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
+    const decodedValue = decodeURIComponent(
+      atob(formattedValue).split("").map(function(c) {
+        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+      }).join("")
+    );
+    return decodedValue;
+  } catch (err) {
+    return atob(b64value);
+  }
+}
+function compact(items) {
+  return items.filter(
+    (item) => item !== null && item !== void 0
+  );
+}
+function compactObject(obj) {
+  const newObj = __spreadValues({}, obj);
+  Object.keys(obj).forEach((k) => {
+    const key = k;
+    if (newObj[key] === void 0) {
+      delete newObj[key];
+    }
+  });
+  return newObj;
+}
+
+// src/AuthToken.ts
+function hasJwtMeta(data) {
+  if (!isPlainObject(data)) {
+    return false;
+  }
+  const { iat, exp } = data;
+  return typeof iat === "number" && typeof exp === "number";
+}
+function isTokenExpired(token) {
+  const now = Date.now() / 1e3;
+  return now > token.exp - 300 || now < token.iat + 300;
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((i) => typeof i === "string");
+}
+function isAppOnlyAuthToken(data) {
+  return typeof data.appId === "string" && data.roomId === void 0 && isStringList(data.scopes);
+}
+function isRoomAuthToken(data) {
+  return typeof data.appId === "string" && typeof data.roomId === "string" && typeof data.actor === "number" && (data.id === void 0 || typeof data.id === "string") && isStringList(data.scopes) && (data.maxConnectionsPerRoom === void 0 || typeof data.maxConnectionsPerRoom === "number");
+}
+function isAuthToken(data) {
+  return isAppOnlyAuthToken(data) || isRoomAuthToken(data);
+}
+function parseJwtToken(token) {
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    throw new Error("Authentication error: invalid JWT token");
+  }
+  const data = tryParseJson(b64decode(tokenParts[1]));
+  if (data && hasJwtMeta(data)) {
+    return data;
+  } else {
+    throw new Error("Authentication error: missing JWT metadata");
+  }
+}
+function parseRoomAuthToken(tokenString) {
+  const data = parseJwtToken(tokenString);
+  if (data && isRoomAuthToken(data)) {
+    const _a = data, {
+      maxConnections: _legacyField
+    } = _a, token = __objRest(_a, [
+      "maxConnections"
+    ]);
+    return token;
+  } else {
+    throw new Error(
+      "Authentication error: we expected a room token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback"
+    );
+  }
+}
+
+// src/lib/fancy-console.ts
+var badge = "background:radial-gradient(106.94% 108.33% at -10% -5%,#ff1aa3 0,#ff881a 100%);border-radius:3px;color:#fff;padding:2px 5px;font-family:sans-serif;font-weight:600";
+var bold = "font-weight:600";
+function wrap(method) {
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (message, ...args) => console[method]("%cLiveblocks", badge, message, ...args);
+}
+var warn = wrap("warn");
+var error = wrap("error");
+function wrapWithTitle(method) {
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (title, message, ...args) => console[method](
+    `%cLiveblocks%c ${title}`,
+    badge,
+    bold,
+    message,
+    ...args
+  );
+}
+var errorWithTitle = wrapWithTitle("error");
+
+// src/lib/deprecation.ts
+var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
+function deprecate(message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!_emittedDeprecationWarnings.has(key)) {
+      _emittedDeprecationWarnings.add(key);
+      errorWithTitle("Deprecation warning", message);
+    }
+  }
+}
+function deprecateIf(condition, message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      deprecate(message, key);
+    }
+  }
+}
+function throwUsageError(message) {
+  if (process.env.NODE_ENV !== "production") {
+    const usageError = new Error(message);
+    usageError.name = "Usage error";
+    errorWithTitle("Usage error", message);
+    throw usageError;
+  }
+}
+function errorIf(condition, message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      throwUsageError(message);
+    }
+  }
+}
+
+// src/lib/assert.ts
 function assertNever(_value, errmsg) {
   throw new Error(errmsg);
 }
@@ -66,16 +220,7 @@ function nn(value, errmsg = "Expected value to be non-nullable") {
   return value;
 }
 
-// src/types/ClientMsg.ts
-var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
-  ClientMsgCode2[ClientMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
-  ClientMsgCode2[ClientMsgCode2["BROADCAST_EVENT"] = 103] = "BROADCAST_EVENT";
-  ClientMsgCode2[ClientMsgCode2["FETCH_STORAGE"] = 200] = "FETCH_STORAGE";
-  ClientMsgCode2[ClientMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
-  return ClientMsgCode2;
-})(ClientMsgCode || {});
-
-// src/types/Op.ts
+// src/protocol/Op.ts
 var OpCode = /* @__PURE__ */ ((OpCode2) => {
   OpCode2[OpCode2["INIT"] = 0] = "INIT";
   OpCode2[OpCode2["SET_PARENT_KEY"] = 1] = "SET_PARENT_KEY";
@@ -89,50 +234,7 @@ var OpCode = /* @__PURE__ */ ((OpCode2) => {
   return OpCode2;
 })(OpCode || {});
 
-// src/types/SerializedCrdt.ts
-var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
-  CrdtType2[CrdtType2["OBJECT"] = 0] = "OBJECT";
-  CrdtType2[CrdtType2["LIST"] = 1] = "LIST";
-  CrdtType2[CrdtType2["MAP"] = 2] = "MAP";
-  CrdtType2[CrdtType2["REGISTER"] = 3] = "REGISTER";
-  return CrdtType2;
-})(CrdtType || {});
-function isRootCrdt(crdt) {
-  return crdt.type === 0 /* OBJECT */ && !isChildCrdt(crdt);
-}
-function isChildCrdt(crdt) {
-  return crdt.parentId !== void 0 && crdt.parentKey !== void 0;
-}
-
-// src/types/ServerMsg.ts
-var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
-  ServerMsgCode2[ServerMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
-  ServerMsgCode2[ServerMsgCode2["USER_JOINED"] = 101] = "USER_JOINED";
-  ServerMsgCode2[ServerMsgCode2["USER_LEFT"] = 102] = "USER_LEFT";
-  ServerMsgCode2[ServerMsgCode2["BROADCASTED_EVENT"] = 103] = "BROADCASTED_EVENT";
-  ServerMsgCode2[ServerMsgCode2["ROOM_STATE"] = 104] = "ROOM_STATE";
-  ServerMsgCode2[ServerMsgCode2["INITIAL_STORAGE_STATE"] = 200] = "INITIAL_STORAGE_STATE";
-  ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
-  return ServerMsgCode2;
-})(ServerMsgCode || {});
-
-// src/types/index.ts
-function isRoomEventName(value) {
-  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history";
-}
-var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
-  return WebsocketCloseCodes2;
-})(WebsocketCloseCodes || {});
-
-// src/AbstractCrdt.ts
+// src/crdts/AbstractCrdt.ts
 function crdtAsLiveNode(value) {
   return value;
 }
@@ -270,63 +372,7 @@ var AbstractCrdt = class {
   }
 };
 
-// src/LiveRegister.ts
-var LiveRegister = class extends AbstractCrdt {
-  constructor(data) {
-    super();
-    this._data = data;
-  }
-  get data() {
-    return this._data;
-  }
-  static _deserialize([id, item], _parentToChildren, pool) {
-    const register = new LiveRegister(item.data);
-    register._attach(id, pool);
-    return register;
-  }
-  _toOps(parentId, parentKey, pool) {
-    if (this._id === void 0) {
-      throw new Error(
-        "Cannot serialize register if parentId or parentKey is undefined"
-      );
-    }
-    return [
-      {
-        type: 8 /* CREATE_REGISTER */,
-        opId: pool == null ? void 0 : pool.generateOpId(),
-        id: this._id,
-        parentId,
-        parentKey,
-        data: this.data
-      }
-    ];
-  }
-  _serialize() {
-    if (this.parent.type !== "HasParent") {
-      throw new Error("Cannot serialize LiveRegister if parent is missing");
-    }
-    return {
-      type: 3 /* REGISTER */,
-      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-      parentKey: this.parent.key,
-      data: this.data
-    };
-  }
-  _attachChild(_op) {
-    throw new Error("Method not implemented.");
-  }
-  _detachChild(_crdt) {
-    throw new Error("Method not implemented.");
-  }
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
-  }
-  _toImmutable() {
-    return this._data;
-  }
-};
-
-// src/position.ts
+// src/lib/position.ts
 var min = 32;
 var max = 126;
 function makePosition(before, after) {
@@ -430,9 +476,80 @@ function comparePosition(posA, posB) {
   );
 }
 
-// src/LiveList.ts
-function compareNodePosition(itemA, itemB) {
-  return comparePosition(
+// src/protocol/SerializedCrdt.ts
+var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
+  CrdtType2[CrdtType2["OBJECT"] = 0] = "OBJECT";
+  CrdtType2[CrdtType2["LIST"] = 1] = "LIST";
+  CrdtType2[CrdtType2["MAP"] = 2] = "MAP";
+  CrdtType2[CrdtType2["REGISTER"] = 3] = "REGISTER";
+  return CrdtType2;
+})(CrdtType || {});
+function isRootCrdt(crdt) {
+  return crdt.type === 0 /* OBJECT */ && !isChildCrdt(crdt);
+}
+function isChildCrdt(crdt) {
+  return crdt.parentId !== void 0 && crdt.parentKey !== void 0;
+}
+
+// src/crdts/LiveRegister.ts
+var LiveRegister = class extends AbstractCrdt {
+  constructor(data) {
+    super();
+    this._data = data;
+  }
+  get data() {
+    return this._data;
+  }
+  static _deserialize([id, item], _parentToChildren, pool) {
+    const register = new LiveRegister(item.data);
+    register._attach(id, pool);
+    return register;
+  }
+  _toOps(parentId, parentKey, pool) {
+    if (this._id === void 0) {
+      throw new Error(
+        "Cannot serialize register if parentId or parentKey is undefined"
+      );
+    }
+    return [
+      {
+        type: 8 /* CREATE_REGISTER */,
+        opId: pool == null ? void 0 : pool.generateOpId(),
+        id: this._id,
+        parentId,
+        parentKey,
+        data: this.data
+      }
+    ];
+  }
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveRegister if parent is missing");
+    }
+    return {
+      type: 3 /* REGISTER */,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key,
+      data: this.data
+    };
+  }
+  _attachChild(_op) {
+    throw new Error("Method not implemented.");
+  }
+  _detachChild(_crdt) {
+    throw new Error("Method not implemented.");
+  }
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
+  }
+  _toImmutable() {
+    return this._data;
+  }
+};
+
+// src/crdts/LiveList.ts
+function compareNodePosition(itemA, itemB) {
+  return comparePosition(
     itemA._getParentKeyOrThrow(),
     itemB._getParentKeyOrThrow()
   );
@@ -1315,7 +1432,10 @@ function addIntentAndDeletedIdToOperation(ops, deletedId) {
   firstOp.deletedId = deletedId;
 }
 
-// src/LiveMap.ts
+// src/lib/freeze.ts
+var freeze = process.env.NODE_ENV === "production" ? (x) => x : Object.freeze;
+
+// src/crdts/LiveMap.ts
 var LiveMap = class extends AbstractCrdt {
   constructor(entries2) {
     super();
@@ -1589,239 +1709,483 @@ var LiveMap = class extends AbstractCrdt {
   }
 };
 
-// src/LiveObject.ts
-var LiveObject = class extends AbstractCrdt {
-  constructor(obj = {}) {
-    super();
-    this._propToLastUpdate = /* @__PURE__ */ new Map();
-    for (const key in obj) {
-      const value = obj[key];
-      if (value === void 0) {
-        continue;
-      } else if (isLiveNode(value)) {
-        value._setParentLink(this, key);
-      }
-    }
-    this._map = new Map(Object.entries(obj));
+// src/liveblocks-helpers.ts
+function creationOpToLiveNode(op) {
+  return lsonToLiveNode(creationOpToLson(op));
+}
+function creationOpToLson(op) {
+  switch (op.type) {
+    case 8 /* CREATE_REGISTER */:
+      return op.data;
+    case 4 /* CREATE_OBJECT */:
+      return new LiveObject(op.data);
+    case 7 /* CREATE_MAP */:
+      return new LiveMap();
+    case 2 /* CREATE_LIST */:
+      return new LiveList();
+    default:
+      return assertNever(op, "Unknown creation Op");
   }
-  _toOps(parentId, parentKey, pool) {
-    if (this._id === void 0) {
-      throw new Error("Cannot serialize item is not attached");
-    }
-    const opId = pool == null ? void 0 : pool.generateOpId();
-    const ops = [];
-    const op = parentId !== void 0 && parentKey !== void 0 ? {
-      type: 4 /* CREATE_OBJECT */,
-      id: this._id,
-      opId,
-      parentId,
-      parentKey,
-      data: {}
-    } : { type: 4 /* CREATE_OBJECT */, id: this._id, opId, data: {} };
-    ops.push(op);
-    for (const [key, value] of this._map) {
-      if (isLiveNode(value)) {
-        ops.push(...value._toOps(this._id, key, pool));
-      } else {
-        op.data[key] = value;
-      }
-    }
-    return ops;
+}
+function isSameNodeOrChildOf(node, parent) {
+  if (node === parent) {
+    return true;
   }
-  static _deserialize([id, item], parentToChildren, pool) {
-    const liveObj = new LiveObject(item.data);
-    liveObj._attach(id, pool);
-    return this._deserializeChildren(liveObj, parentToChildren, pool);
+  if (node.parent.type === "HasParent") {
+    return isSameNodeOrChildOf(node.parent.node, parent);
   }
-  static _deserializeChildren(liveObj, parentToChildren, pool) {
-    const children = parentToChildren.get(nn(liveObj._id));
-    if (children === void 0) {
-      return liveObj;
+  return false;
+}
+function deserialize([id, crdt], parentToChildren, pool) {
+  switch (crdt.type) {
+    case 0 /* OBJECT */: {
+      return LiveObject._deserialize([id, crdt], parentToChildren, pool);
     }
-    for (const [id, crdt] of children) {
-      const child = deserializeToLson([id, crdt], parentToChildren, pool);
-      if (isLiveStructure(child)) {
-        child._setParentLink(liveObj, crdt.parentKey);
-      }
-      liveObj._map.set(crdt.parentKey, child);
-      liveObj.invalidate();
+    case 1 /* LIST */: {
+      return LiveList._deserialize([id, crdt], parentToChildren, pool);
     }
-    return liveObj;
-  }
-  _attach(id, pool) {
-    super._attach(id, pool);
-    for (const [_key, value] of this._map) {
-      if (isLiveNode(value)) {
-        value._attach(pool.generateId(), pool);
-      }
+    case 2 /* MAP */: {
+      return LiveMap._deserialize([id, crdt], parentToChildren, pool);
     }
-  }
-  _attachChild(op, source) {
-    if (this._pool === void 0) {
-      throw new Error("Can't attach child if managed pool is not present");
+    case 3 /* REGISTER */: {
+      return LiveRegister._deserialize([id, crdt], parentToChildren, pool);
     }
-    const { id, opId, parentKey: key } = op;
-    const child = creationOpToLson(op);
-    if (this._pool.getNode(id) !== void 0) {
-      if (this._propToLastUpdate.get(key) === opId) {
-        this._propToLastUpdate.delete(key);
-      }
-      return { modified: false };
+    default: {
+      throw new Error("Unexpected CRDT type");
     }
-    if (source === 0 /* UNDOREDO_RECONNECT */) {
-      this._propToLastUpdate.set(key, nn(opId));
-    } else if (this._propToLastUpdate.get(key) === void 0) {
-    } else if (this._propToLastUpdate.get(key) === opId) {
-      this._propToLastUpdate.delete(key);
-      return { modified: false };
-    } else {
-      return { modified: false };
+  }
+}
+function deserializeToLson([id, crdt], parentToChildren, pool) {
+  switch (crdt.type) {
+    case 0 /* OBJECT */: {
+      return LiveObject._deserialize([id, crdt], parentToChildren, pool);
     }
-    const thisId = nn(this._id);
-    const previousValue = this._map.get(key);
-    let reverse;
-    if (isLiveNode(previousValue)) {
-      reverse = previousValue._toOps(thisId, key);
-      previousValue._detach();
-    } else if (previousValue === void 0) {
-      reverse = [{ type: 6 /* DELETE_OBJECT_KEY */, id: thisId, key }];
-    } else {
-      reverse = [
-        {
-          type: 3 /* UPDATE_OBJECT */,
-          id: thisId,
-          data: { [key]: previousValue }
-        }
-      ];
+    case 1 /* LIST */: {
+      return LiveList._deserialize([id, crdt], parentToChildren, pool);
     }
-    this._map.set(key, child);
-    this.invalidate();
-    if (isLiveStructure(child)) {
-      child._setParentLink(this, key);
-      child._attach(id, this._pool);
+    case 2 /* MAP */: {
+      return LiveMap._deserialize([id, crdt], parentToChildren, pool);
     }
-    return {
-      reverse,
-      modified: {
-        node: this,
-        type: "LiveObject",
-        updates: { [key]: { type: "update" } }
-      }
-    };
-  }
-  _detachChild(child) {
-    if (child) {
-      const id = nn(this._id);
-      const parentKey = nn(child._parentKey);
-      const reverse = child._toOps(id, parentKey, this._pool);
-      for (const [key, value] of this._map) {
-        if (value === child) {
-          this._map.delete(key);
-          this.invalidate();
-        }
-      }
-      child._detach();
-      const storageUpdate = {
-        node: this,
-        type: "LiveObject",
-        updates: {
-          [parentKey]: { type: "delete" }
-        }
-      };
-      return { modified: storageUpdate, reverse };
+    case 3 /* REGISTER */: {
+      return crdt.data;
+    }
+    default: {
+      throw new Error("Unexpected CRDT type");
     }
-    return { modified: false };
   }
-  _detach() {
-    super._detach();
-    for (const value of this._map.values()) {
-      if (isLiveNode(value)) {
-        value._detach();
-      }
-    }
+}
+function isLiveStructure(value) {
+  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
+}
+function isLiveNode(value) {
+  return isLiveStructure(value) || isLiveRegister(value);
+}
+function isLiveList(value) {
+  return value instanceof LiveList;
+}
+function isLiveMap(value) {
+  return value instanceof LiveMap;
+}
+function isLiveObject(value) {
+  return value instanceof LiveObject;
+}
+function isLiveRegister(value) {
+  return value instanceof LiveRegister;
+}
+function liveNodeToLson(obj) {
+  if (obj instanceof LiveRegister) {
+    return obj.data;
+  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
+    return obj;
+  } else {
+    return assertNever(obj, "Unknown AbstractCrdt");
   }
-  _apply(op, isLocal) {
-    if (op.type === 3 /* UPDATE_OBJECT */) {
-      return this._applyUpdate(op, isLocal);
-    } else if (op.type === 6 /* DELETE_OBJECT_KEY */) {
-      return this._applyDeleteObjectKey(op);
-    }
-    return super._apply(op, isLocal);
+}
+function lsonToLiveNode(value) {
+  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
+    return value;
+  } else {
+    return new LiveRegister(value);
   }
-  _serialize() {
-    const data = {};
-    for (const [key, value] of this._map) {
-      if (!isLiveNode(value)) {
-        data[key] = value;
-      }
+}
+function getTreesDiffOperations(currentItems, newItems) {
+  const ops = [];
+  currentItems.forEach((_, id) => {
+    if (!newItems.get(id)) {
+      ops.push({
+        type: 5 /* DELETE_CRDT */,
+        id
+      });
     }
-    if (this.parent.type === "HasParent" && this.parent.node._id) {
-      return {
-        type: 0 /* OBJECT */,
-        parentId: this.parent.node._id,
-        parentKey: this.parent.key,
-        data
-      };
+  });
+  newItems.forEach((crdt, id) => {
+    const currentCrdt = currentItems.get(id);
+    if (currentCrdt) {
+      if (crdt.type === 0 /* OBJECT */) {
+        if (currentCrdt.type !== 0 /* OBJECT */ || JSON.stringify(crdt.data) !== JSON.stringify(currentCrdt.data)) {
+          ops.push({
+            type: 3 /* UPDATE_OBJECT */,
+            id,
+            data: crdt.data
+          });
+        }
+      }
+      if (crdt.parentKey !== currentCrdt.parentKey) {
+        ops.push({
+          type: 1 /* SET_PARENT_KEY */,
+          id,
+          parentKey: nn(crdt.parentKey, "Parent key must not be missing")
+        });
+      }
     } else {
-      return {
-        type: 0 /* OBJECT */,
-        data
-      };
+      switch (crdt.type) {
+        case 3 /* REGISTER */:
+          ops.push({
+            type: 8 /* CREATE_REGISTER */,
+            id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey,
+            data: crdt.data
+          });
+          break;
+        case 1 /* LIST */:
+          ops.push({
+            type: 2 /* CREATE_LIST */,
+            id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey
+          });
+          break;
+        case 0 /* OBJECT */:
+          ops.push(
+            crdt.parentId ? {
+              type: 4 /* CREATE_OBJECT */,
+              id,
+              parentId: crdt.parentId,
+              parentKey: crdt.parentKey,
+              data: crdt.data
+            } : { type: 4 /* CREATE_OBJECT */, id, data: crdt.data }
+          );
+          break;
+        case 2 /* MAP */:
+          ops.push({
+            type: 7 /* CREATE_MAP */,
+            id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey
+          });
+          break;
+      }
     }
+  });
+  return ops;
+}
+function mergeObjectStorageUpdates(first, second) {
+  const updates = first.updates;
+  for (const [key, value] of entries(second.updates)) {
+    updates[key] = value;
   }
-  _applyUpdate(op, isLocal) {
-    let isModified = false;
-    const id = nn(this._id);
-    const reverse = [];
-    const reverseUpdate = {
-      type: 3 /* UPDATE_OBJECT */,
-      id,
-      data: {}
+  return __spreadProps(__spreadValues({}, second), {
+    updates
+  });
+}
+function mergeMapStorageUpdates(first, second) {
+  const updates = first.updates;
+  for (const [key, value] of entries(second.updates)) {
+    updates[key] = value;
+  }
+  return __spreadProps(__spreadValues({}, second), {
+    updates
+  });
+}
+function mergeListStorageUpdates(first, second) {
+  const updates = first.updates;
+  return __spreadProps(__spreadValues({}, second), {
+    updates: updates.concat(second.updates)
+  });
+}
+function mergeStorageUpdates(first, second) {
+  if (!first) {
+    return second;
+  }
+  if (first.type === "LiveObject" && second.type === "LiveObject") {
+    return mergeObjectStorageUpdates(first, second);
+  } else if (first.type === "LiveMap" && second.type === "LiveMap") {
+    return mergeMapStorageUpdates(first, second);
+  } else if (first.type === "LiveList" && second.type === "LiveList") {
+    return mergeListStorageUpdates(first, second);
+  } else {
+  }
+  return second;
+}
+function isPlain(value) {
+  const type = typeof value;
+  return value === void 0 || value === null || type === "string" || type === "boolean" || type === "number" || Array.isArray(value) || isPlainObject(value);
+}
+function findNonSerializableValue(value, path = "") {
+  if (!isPlain) {
+    return {
+      path: path || "root",
+      value
     };
-    reverse.push(reverseUpdate);
-    for (const key in op.data) {
-      const oldValue = this._map.get(key);
-      if (isLiveNode(oldValue)) {
-        reverse.push(...oldValue._toOps(id, key));
-        oldValue._detach();
-      } else if (oldValue !== void 0) {
-        reverseUpdate.data[key] = oldValue;
-      } else if (oldValue === void 0) {
-        reverse.push({ type: 6 /* DELETE_OBJECT_KEY */, id, key });
+  }
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  for (const [key, nestedValue] of Object.entries(value)) {
+    const nestedPath = path ? path + "." + key : key;
+    if (!isPlain(nestedValue)) {
+      return {
+        path: nestedPath,
+        value: nestedValue
+      };
+    }
+    if (typeof nestedValue === "object") {
+      const nonSerializableNestedValue = findNonSerializableValue(
+        nestedValue,
+        nestedPath
+      );
+      if (nonSerializableNestedValue) {
+        return nonSerializableNestedValue;
       }
     }
-    const updateDelta = {};
-    for (const key in op.data) {
-      const value = op.data[key];
+  }
+  return false;
+}
+
+// src/crdts/LiveObject.ts
+var LiveObject = class extends AbstractCrdt {
+  constructor(obj = {}) {
+    super();
+    this._propToLastUpdate = /* @__PURE__ */ new Map();
+    for (const key in obj) {
+      const value = obj[key];
       if (value === void 0) {
         continue;
+      } else if (isLiveNode(value)) {
+        value._setParentLink(this, key);
       }
-      if (isLocal) {
-        this._propToLastUpdate.set(key, nn(op.opId));
-      } else if (this._propToLastUpdate.get(key) === void 0) {
-        isModified = true;
-      } else if (this._propToLastUpdate.get(key) === op.opId) {
-        this._propToLastUpdate.delete(key);
-        continue;
-      } else {
-        continue;
-      }
-      const oldValue = this._map.get(key);
-      if (isLiveNode(oldValue)) {
-        oldValue._detach();
-      }
-      isModified = true;
-      updateDelta[key] = { type: "update" };
-      this._map.set(key, value);
-      this.invalidate();
     }
-    if (Object.keys(reverseUpdate.data).length !== 0) {
-      reverse.unshift(reverseUpdate);
+    this._map = new Map(Object.entries(obj));
+  }
+  _toOps(parentId, parentKey, pool) {
+    if (this._id === void 0) {
+      throw new Error("Cannot serialize item is not attached");
     }
-    return isModified ? {
-      modified: {
-        node: this,
-        type: "LiveObject",
+    const opId = pool == null ? void 0 : pool.generateOpId();
+    const ops = [];
+    const op = parentId !== void 0 && parentKey !== void 0 ? {
+      type: 4 /* CREATE_OBJECT */,
+      id: this._id,
+      opId,
+      parentId,
+      parentKey,
+      data: {}
+    } : { type: 4 /* CREATE_OBJECT */, id: this._id, opId, data: {} };
+    ops.push(op);
+    for (const [key, value] of this._map) {
+      if (isLiveNode(value)) {
+        ops.push(...value._toOps(this._id, key, pool));
+      } else {
+        op.data[key] = value;
+      }
+    }
+    return ops;
+  }
+  static _deserialize([id, item], parentToChildren, pool) {
+    const liveObj = new LiveObject(item.data);
+    liveObj._attach(id, pool);
+    return this._deserializeChildren(liveObj, parentToChildren, pool);
+  }
+  static _deserializeChildren(liveObj, parentToChildren, pool) {
+    const children = parentToChildren.get(nn(liveObj._id));
+    if (children === void 0) {
+      return liveObj;
+    }
+    for (const [id, crdt] of children) {
+      const child = deserializeToLson([id, crdt], parentToChildren, pool);
+      if (isLiveStructure(child)) {
+        child._setParentLink(liveObj, crdt.parentKey);
+      }
+      liveObj._map.set(crdt.parentKey, child);
+      liveObj.invalidate();
+    }
+    return liveObj;
+  }
+  _attach(id, pool) {
+    super._attach(id, pool);
+    for (const [_key, value] of this._map) {
+      if (isLiveNode(value)) {
+        value._attach(pool.generateId(), pool);
+      }
+    }
+  }
+  _attachChild(op, source) {
+    if (this._pool === void 0) {
+      throw new Error("Can't attach child if managed pool is not present");
+    }
+    const { id, opId, parentKey: key } = op;
+    const child = creationOpToLson(op);
+    if (this._pool.getNode(id) !== void 0) {
+      if (this._propToLastUpdate.get(key) === opId) {
+        this._propToLastUpdate.delete(key);
+      }
+      return { modified: false };
+    }
+    if (source === 0 /* UNDOREDO_RECONNECT */) {
+      this._propToLastUpdate.set(key, nn(opId));
+    } else if (this._propToLastUpdate.get(key) === void 0) {
+    } else if (this._propToLastUpdate.get(key) === opId) {
+      this._propToLastUpdate.delete(key);
+      return { modified: false };
+    } else {
+      return { modified: false };
+    }
+    const thisId = nn(this._id);
+    const previousValue = this._map.get(key);
+    let reverse;
+    if (isLiveNode(previousValue)) {
+      reverse = previousValue._toOps(thisId, key);
+      previousValue._detach();
+    } else if (previousValue === void 0) {
+      reverse = [{ type: 6 /* DELETE_OBJECT_KEY */, id: thisId, key }];
+    } else {
+      reverse = [
+        {
+          type: 3 /* UPDATE_OBJECT */,
+          id: thisId,
+          data: { [key]: previousValue }
+        }
+      ];
+    }
+    this._map.set(key, child);
+    this.invalidate();
+    if (isLiveStructure(child)) {
+      child._setParentLink(this, key);
+      child._attach(id, this._pool);
+    }
+    return {
+      reverse,
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: { [key]: { type: "update" } }
+      }
+    };
+  }
+  _detachChild(child) {
+    if (child) {
+      const id = nn(this._id);
+      const parentKey = nn(child._parentKey);
+      const reverse = child._toOps(id, parentKey, this._pool);
+      for (const [key, value] of this._map) {
+        if (value === child) {
+          this._map.delete(key);
+          this.invalidate();
+        }
+      }
+      child._detach();
+      const storageUpdate = {
+        node: this,
+        type: "LiveObject",
+        updates: {
+          [parentKey]: { type: "delete" }
+        }
+      };
+      return { modified: storageUpdate, reverse };
+    }
+    return { modified: false };
+  }
+  _detach() {
+    super._detach();
+    for (const value of this._map.values()) {
+      if (isLiveNode(value)) {
+        value._detach();
+      }
+    }
+  }
+  _apply(op, isLocal) {
+    if (op.type === 3 /* UPDATE_OBJECT */) {
+      return this._applyUpdate(op, isLocal);
+    } else if (op.type === 6 /* DELETE_OBJECT_KEY */) {
+      return this._applyDeleteObjectKey(op);
+    }
+    return super._apply(op, isLocal);
+  }
+  _serialize() {
+    const data = {};
+    for (const [key, value] of this._map) {
+      if (!isLiveNode(value)) {
+        data[key] = value;
+      }
+    }
+    if (this.parent.type === "HasParent" && this.parent.node._id) {
+      return {
+        type: 0 /* OBJECT */,
+        parentId: this.parent.node._id,
+        parentKey: this.parent.key,
+        data
+      };
+    } else {
+      return {
+        type: 0 /* OBJECT */,
+        data
+      };
+    }
+  }
+  _applyUpdate(op, isLocal) {
+    let isModified = false;
+    const id = nn(this._id);
+    const reverse = [];
+    const reverseUpdate = {
+      type: 3 /* UPDATE_OBJECT */,
+      id,
+      data: {}
+    };
+    reverse.push(reverseUpdate);
+    for (const key in op.data) {
+      const oldValue = this._map.get(key);
+      if (isLiveNode(oldValue)) {
+        reverse.push(...oldValue._toOps(id, key));
+        oldValue._detach();
+      } else if (oldValue !== void 0) {
+        reverseUpdate.data[key] = oldValue;
+      } else if (oldValue === void 0) {
+        reverse.push({ type: 6 /* DELETE_OBJECT_KEY */, id, key });
+      }
+    }
+    const updateDelta = {};
+    for (const key in op.data) {
+      const value = op.data[key];
+      if (value === void 0) {
+        continue;
+      }
+      if (isLocal) {
+        this._propToLastUpdate.set(key, nn(op.opId));
+      } else if (this._propToLastUpdate.get(key) === void 0) {
+        isModified = true;
+      } else if (this._propToLastUpdate.get(key) === op.opId) {
+        this._propToLastUpdate.delete(key);
+        continue;
+      } else {
+        continue;
+      }
+      const oldValue = this._map.get(key);
+      if (isLiveNode(oldValue)) {
+        oldValue._detach();
+      }
+      isModified = true;
+      updateDelta[key] = { type: "update" };
+      this._map.set(key, value);
+      this.invalidate();
+    }
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+      reverse.unshift(reverseUpdate);
+    }
+    return isModified ? {
+      modified: {
+        node: this,
+        type: "LiveObject",
         updates: updateDelta
       },
       reverse
@@ -1867,554 +2231,157 @@ var LiveObject = class extends AbstractCrdt {
   set(key, value) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
-    this.update({ [key]: value });
-  }
-  get(key) {
-    return this._map.get(key);
-  }
-  delete(key) {
-    var _a;
-    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
-    const keyAsString = key;
-    const oldValue = this._map.get(keyAsString);
-    if (oldValue === void 0) {
-      return;
-    }
-    if (this._pool === void 0 || this._id === void 0) {
-      if (isLiveNode(oldValue)) {
-        oldValue._detach();
-      }
-      this._map.delete(keyAsString);
-      this.invalidate();
-      return;
-    }
-    let reverse;
-    if (isLiveNode(oldValue)) {
-      oldValue._detach();
-      reverse = oldValue._toOps(this._id, keyAsString);
-    } else {
-      reverse = [
-        {
-          type: 3 /* UPDATE_OBJECT */,
-          data: { [keyAsString]: oldValue },
-          id: this._id
-        }
-      ];
-    }
-    this._map.delete(keyAsString);
-    this.invalidate();
-    const storageUpdates = /* @__PURE__ */ new Map();
-    storageUpdates.set(this._id, {
-      node: this,
-      type: "LiveObject",
-      updates: { [key]: { type: "delete" } }
-    });
-    this._pool.dispatch(
-      [
-        {
-          type: 6 /* DELETE_OBJECT_KEY */,
-          key: keyAsString,
-          id: this._id,
-          opId: this._pool.generateOpId()
-        }
-      ],
-      reverse,
-      storageUpdates
-    );
-  }
-  update(patch) {
-    var _a;
-    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
-    if (this._pool === void 0 || this._id === void 0) {
-      for (const key in patch) {
-        const newValue = patch[key];
-        if (newValue === void 0) {
-          continue;
-        }
-        const oldValue = this._map.get(key);
-        if (isLiveNode(oldValue)) {
-          oldValue._detach();
-        }
-        if (isLiveNode(newValue)) {
-          newValue._setParentLink(this, key);
-        }
-        this._map.set(key, newValue);
-        this.invalidate();
-      }
-      return;
-    }
-    const ops = [];
-    const reverseOps = [];
-    const opId = this._pool.generateOpId();
-    const updatedProps = {};
-    const reverseUpdateOp = {
-      id: this._id,
-      type: 3 /* UPDATE_OBJECT */,
-      data: {}
-    };
-    const updateDelta = {};
-    for (const key in patch) {
-      const newValue = patch[key];
-      if (newValue === void 0) {
-        continue;
-      }
-      const oldValue = this._map.get(key);
-      if (isLiveNode(oldValue)) {
-        reverseOps.push(...oldValue._toOps(this._id, key));
-        oldValue._detach();
-      } else if (oldValue === void 0) {
-        reverseOps.push({ type: 6 /* DELETE_OBJECT_KEY */, id: this._id, key });
-      } else {
-        reverseUpdateOp.data[key] = oldValue;
-      }
-      if (isLiveNode(newValue)) {
-        newValue._setParentLink(this, key);
-        newValue._attach(this._pool.generateId(), this._pool);
-        const newAttachChildOps = newValue._toOps(this._id, key, this._pool);
-        const createCrdtOp = newAttachChildOps.find(
-          (op) => op.parentId === this._id
-        );
-        if (createCrdtOp) {
-          this._propToLastUpdate.set(key, nn(createCrdtOp.opId));
-        }
-        ops.push(...newAttachChildOps);
-      } else {
-        updatedProps[key] = newValue;
-        this._propToLastUpdate.set(key, opId);
-      }
-      this._map.set(key, newValue);
-      this.invalidate();
-      updateDelta[key] = { type: "update" };
-    }
-    if (Object.keys(reverseUpdateOp.data).length !== 0) {
-      reverseOps.unshift(reverseUpdateOp);
-    }
-    if (Object.keys(updatedProps).length !== 0) {
-      ops.unshift({
-        opId,
-        id: this._id,
-        type: 3 /* UPDATE_OBJECT */,
-        data: updatedProps
-      });
-    }
-    const storageUpdates = /* @__PURE__ */ new Map();
-    storageUpdates.set(this._id, {
-      node: this,
-      type: "LiveObject",
-      updates: updateDelta
-    });
-    this._pool.dispatch(ops, reverseOps, storageUpdates);
-  }
-  toImmutable() {
-    return super.toImmutable();
-  }
-  _toImmutable() {
-    const result = {};
-    for (const [key, val] of this._map) {
-      result[key] = isLiveStructure(val) ? val.toImmutable() : val;
-    }
-    return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
-  }
-};
-
-// src/utils.ts
-var freeze = process.env.NODE_ENV === "production" ? (x) => x : Object.freeze;
-function compact(items) {
-  return items.filter(
-    (item) => item !== null && item !== void 0
-  );
-}
-function compactObject(obj) {
-  const newObj = __spreadValues({}, obj);
-  Object.keys(obj).forEach((k) => {
-    const key = k;
-    if (newObj[key] === void 0) {
-      delete newObj[key];
-    }
-  });
-  return newObj;
-}
-function creationOpToLiveNode(op) {
-  return lsonToLiveNode(creationOpToLson(op));
-}
-function creationOpToLson(op) {
-  switch (op.type) {
-    case 8 /* CREATE_REGISTER */:
-      return op.data;
-    case 4 /* CREATE_OBJECT */:
-      return new LiveObject(op.data);
-    case 7 /* CREATE_MAP */:
-      return new LiveMap();
-    case 2 /* CREATE_LIST */:
-      return new LiveList();
-    default:
-      return assertNever(op, "Unknown creation Op");
-  }
-}
-function isSameNodeOrChildOf(node, parent) {
-  if (node === parent) {
-    return true;
-  }
-  if (node.parent.type === "HasParent") {
-    return isSameNodeOrChildOf(node.parent.node, parent);
-  }
-  return false;
-}
-function deserialize([id, crdt], parentToChildren, pool) {
-  switch (crdt.type) {
-    case 0 /* OBJECT */: {
-      return LiveObject._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 1 /* LIST */: {
-      return LiveList._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 2 /* MAP */: {
-      return LiveMap._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 3 /* REGISTER */: {
-      return LiveRegister._deserialize([id, crdt], parentToChildren, pool);
-    }
-    default: {
-      throw new Error("Unexpected CRDT type");
-    }
-  }
-}
-function deserializeToLson([id, crdt], parentToChildren, pool) {
-  switch (crdt.type) {
-    case 0 /* OBJECT */: {
-      return LiveObject._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 1 /* LIST */: {
-      return LiveList._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 2 /* MAP */: {
-      return LiveMap._deserialize([id, crdt], parentToChildren, pool);
-    }
-    case 3 /* REGISTER */: {
-      return crdt.data;
-    }
-    default: {
-      throw new Error("Unexpected CRDT type");
-    }
-  }
-}
-function isLiveStructure(value) {
-  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
-}
-function isLiveNode(value) {
-  return isLiveStructure(value) || isLiveRegister(value);
-}
-function isLiveList(value) {
-  return value instanceof LiveList;
-}
-function isLiveMap(value) {
-  return value instanceof LiveMap;
-}
-function isLiveObject(value) {
-  return value instanceof LiveObject;
-}
-function isLiveRegister(value) {
-  return value instanceof LiveRegister;
-}
-function liveNodeToLson(obj) {
-  if (obj instanceof LiveRegister) {
-    return obj.data;
-  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
-    return obj;
-  } else {
-    return assertNever(obj, "Unknown AbstractCrdt");
-  }
-}
-function lsonToLiveNode(value) {
-  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
-    return value;
-  } else {
-    return new LiveRegister(value);
-  }
-}
-function getTreesDiffOperations(currentItems, newItems) {
-  const ops = [];
-  currentItems.forEach((_, id) => {
-    if (!newItems.get(id)) {
-      ops.push({
-        type: 5 /* DELETE_CRDT */,
-        id
-      });
-    }
-  });
-  newItems.forEach((crdt, id) => {
-    const currentCrdt = currentItems.get(id);
-    if (currentCrdt) {
-      if (crdt.type === 0 /* OBJECT */) {
-        if (currentCrdt.type !== 0 /* OBJECT */ || JSON.stringify(crdt.data) !== JSON.stringify(currentCrdt.data)) {
-          ops.push({
-            type: 3 /* UPDATE_OBJECT */,
-            id,
-            data: crdt.data
-          });
-        }
-      }
-      if (crdt.parentKey !== currentCrdt.parentKey) {
-        ops.push({
-          type: 1 /* SET_PARENT_KEY */,
-          id,
-          parentKey: nn(crdt.parentKey, "Parent key must not be missing")
-        });
-      }
-    } else {
-      switch (crdt.type) {
-        case 3 /* REGISTER */:
-          ops.push({
-            type: 8 /* CREATE_REGISTER */,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey,
-            data: crdt.data
-          });
-          break;
-        case 1 /* LIST */:
-          ops.push({
-            type: 2 /* CREATE_LIST */,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey
-          });
-          break;
-        case 0 /* OBJECT */:
-          ops.push(
-            crdt.parentId ? {
-              type: 4 /* CREATE_OBJECT */,
-              id,
-              parentId: crdt.parentId,
-              parentKey: crdt.parentKey,
-              data: crdt.data
-            } : { type: 4 /* CREATE_OBJECT */, id, data: crdt.data }
-          );
-          break;
-        case 2 /* MAP */:
-          ops.push({
-            type: 7 /* CREATE_MAP */,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey
-          });
-          break;
-      }
-    }
-  });
-  return ops;
-}
-function mergeObjectStorageUpdates(first, second) {
-  const updates = first.updates;
-  for (const [key, value] of entries(second.updates)) {
-    updates[key] = value;
-  }
-  return __spreadProps(__spreadValues({}, second), {
-    updates
-  });
-}
-function mergeMapStorageUpdates(first, second) {
-  const updates = first.updates;
-  for (const [key, value] of entries(second.updates)) {
-    updates[key] = value;
-  }
-  return __spreadProps(__spreadValues({}, second), {
-    updates
-  });
-}
-function mergeListStorageUpdates(first, second) {
-  const updates = first.updates;
-  return __spreadProps(__spreadValues({}, second), {
-    updates: updates.concat(second.updates)
-  });
-}
-function mergeStorageUpdates(first, second) {
-  if (!first) {
-    return second;
-  }
-  if (first.type === "LiveObject" && second.type === "LiveObject") {
-    return mergeObjectStorageUpdates(first, second);
-  } else if (first.type === "LiveMap" && second.type === "LiveMap") {
-    return mergeMapStorageUpdates(first, second);
-  } else if (first.type === "LiveList" && second.type === "LiveList") {
-    return mergeListStorageUpdates(first, second);
-  } else {
-  }
-  return second;
-}
-function isPlain(value) {
-  const type = typeof value;
-  return value === void 0 || value === null || type === "string" || type === "boolean" || type === "number" || Array.isArray(value) || isPlainObject(value);
-}
-function isPlainObject(blob) {
-  return blob !== null && typeof blob === "object" && Object.prototype.toString.call(blob) === "[object Object]";
-}
-function findNonSerializableValue(value, path = "") {
-  if (!isPlain) {
-    return {
-      path: path || "root",
-      value
-    };
-  }
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  for (const [key, nestedValue] of Object.entries(value)) {
-    const nestedPath = path ? path + "." + key : key;
-    if (!isPlain(nestedValue)) {
-      return {
-        path: nestedPath,
-        value: nestedValue
-      };
-    }
-    if (typeof nestedValue === "object") {
-      const nonSerializableNestedValue = findNonSerializableValue(
-        nestedValue,
-        nestedPath
-      );
-      if (nonSerializableNestedValue) {
-        return nonSerializableNestedValue;
-      }
-    }
-  }
-  return false;
-}
-function fromEntries(iterable) {
-  const obj = {};
-  for (const [key, val] of iterable) {
-    obj[key] = val;
-  }
-  return obj;
-}
-function entries(obj) {
-  return Object.entries(obj);
-}
-function tryParseJson(rawMessage) {
-  try {
-    return JSON.parse(rawMessage);
-  } catch (e) {
-    return void 0;
-  }
-}
-function b64decode(b64value) {
-  try {
-    const formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
-    const decodedValue = decodeURIComponent(
-      atob(formattedValue).split("").map(function(c) {
-        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-      }).join("")
-    );
-    return decodedValue;
-  } catch (err) {
-    return atob(b64value);
-  }
-}
-
-// src/AuthToken.ts
-function hasJwtMeta(data) {
-  if (!isPlainObject(data)) {
-    return false;
-  }
-  const { iat, exp } = data;
-  return typeof iat === "number" && typeof exp === "number";
-}
-function isTokenExpired(token) {
-  const now = Date.now() / 1e3;
-  return now > token.exp - 300 || now < token.iat + 300;
-}
-function isStringList(value) {
-  return Array.isArray(value) && value.every((i) => typeof i === "string");
-}
-function isAppOnlyAuthToken(data) {
-  return typeof data.appId === "string" && data.roomId === void 0 && isStringList(data.scopes);
-}
-function isRoomAuthToken(data) {
-  return typeof data.appId === "string" && typeof data.roomId === "string" && typeof data.actor === "number" && (data.id === void 0 || typeof data.id === "string") && isStringList(data.scopes) && (data.maxConnectionsPerRoom === void 0 || typeof data.maxConnectionsPerRoom === "number");
-}
-function isAuthToken(data) {
-  return isAppOnlyAuthToken(data) || isRoomAuthToken(data);
-}
-function parseJwtToken(token) {
-  const tokenParts = token.split(".");
-  if (tokenParts.length !== 3) {
-    throw new Error("Authentication error: invalid JWT token");
+    this.update({ [key]: value });
   }
-  const data = tryParseJson(b64decode(tokenParts[1]));
-  if (data && hasJwtMeta(data)) {
-    return data;
-  } else {
-    throw new Error("Authentication error: missing JWT metadata");
+  get(key) {
+    return this._map.get(key);
   }
-}
-function parseRoomAuthToken(tokenString) {
-  const data = parseJwtToken(tokenString);
-  if (data && isRoomAuthToken(data)) {
-    const _a = data, {
-      maxConnections: _legacyField
-    } = _a, token = __objRest(_a, [
-      "maxConnections"
-    ]);
-    return token;
-  } else {
-    throw new Error(
-      "Authentication error: we expected a room token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback"
+  delete(key) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
+    const keyAsString = key;
+    const oldValue = this._map.get(keyAsString);
+    if (oldValue === void 0) {
+      return;
+    }
+    if (this._pool === void 0 || this._id === void 0) {
+      if (isLiveNode(oldValue)) {
+        oldValue._detach();
+      }
+      this._map.delete(keyAsString);
+      this.invalidate();
+      return;
+    }
+    let reverse;
+    if (isLiveNode(oldValue)) {
+      oldValue._detach();
+      reverse = oldValue._toOps(this._id, keyAsString);
+    } else {
+      reverse = [
+        {
+          type: 3 /* UPDATE_OBJECT */,
+          data: { [keyAsString]: oldValue },
+          id: this._id
+        }
+      ];
+    }
+    this._map.delete(keyAsString);
+    this.invalidate();
+    const storageUpdates = /* @__PURE__ */ new Map();
+    storageUpdates.set(this._id, {
+      node: this,
+      type: "LiveObject",
+      updates: { [key]: { type: "delete" } }
+    });
+    this._pool.dispatch(
+      [
+        {
+          type: 6 /* DELETE_OBJECT_KEY */,
+          key: keyAsString,
+          id: this._id,
+          opId: this._pool.generateOpId()
+        }
+      ],
+      reverse,
+      storageUpdates
     );
   }
-}
-
-// src/fancy-console.ts
-var badge = "background:radial-gradient(106.94% 108.33% at -10% -5%,#ff1aa3 0,#ff881a 100%);border-radius:3px;color:#fff;padding:2px 5px;font-family:sans-serif;font-weight:600";
-var bold = "font-weight:600";
-function wrap(method) {
-  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (message, ...args) => console[method]("%cLiveblocks", badge, message, ...args);
-}
-var warn = wrap("warn");
-var error = wrap("error");
-function wrapWithTitle(method) {
-  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (title, message, ...args) => console[method](
-    `%cLiveblocks%c ${title}`,
-    badge,
-    bold,
-    message,
-    ...args
-  );
-}
-var errorWithTitle = wrapWithTitle("error");
-
-// src/deprecation.ts
-var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
-function deprecate(message, key = message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (!_emittedDeprecationWarnings.has(key)) {
-      _emittedDeprecationWarnings.add(key);
-      errorWithTitle("Deprecation warning", message);
+  update(patch) {
+    var _a;
+    (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
+    if (this._pool === void 0 || this._id === void 0) {
+      for (const key in patch) {
+        const newValue = patch[key];
+        if (newValue === void 0) {
+          continue;
+        }
+        const oldValue = this._map.get(key);
+        if (isLiveNode(oldValue)) {
+          oldValue._detach();
+        }
+        if (isLiveNode(newValue)) {
+          newValue._setParentLink(this, key);
+        }
+        this._map.set(key, newValue);
+        this.invalidate();
+      }
+      return;
     }
-  }
-}
-function deprecateIf(condition, message, key = message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (condition) {
-      deprecate(message, key);
+    const ops = [];
+    const reverseOps = [];
+    const opId = this._pool.generateOpId();
+    const updatedProps = {};
+    const reverseUpdateOp = {
+      id: this._id,
+      type: 3 /* UPDATE_OBJECT */,
+      data: {}
+    };
+    const updateDelta = {};
+    for (const key in patch) {
+      const newValue = patch[key];
+      if (newValue === void 0) {
+        continue;
+      }
+      const oldValue = this._map.get(key);
+      if (isLiveNode(oldValue)) {
+        reverseOps.push(...oldValue._toOps(this._id, key));
+        oldValue._detach();
+      } else if (oldValue === void 0) {
+        reverseOps.push({ type: 6 /* DELETE_OBJECT_KEY */, id: this._id, key });
+      } else {
+        reverseUpdateOp.data[key] = oldValue;
+      }
+      if (isLiveNode(newValue)) {
+        newValue._setParentLink(this, key);
+        newValue._attach(this._pool.generateId(), this._pool);
+        const newAttachChildOps = newValue._toOps(this._id, key, this._pool);
+        const createCrdtOp = newAttachChildOps.find(
+          (op) => op.parentId === this._id
+        );
+        if (createCrdtOp) {
+          this._propToLastUpdate.set(key, nn(createCrdtOp.opId));
+        }
+        ops.push(...newAttachChildOps);
+      } else {
+        updatedProps[key] = newValue;
+        this._propToLastUpdate.set(key, opId);
+      }
+      this._map.set(key, newValue);
+      this.invalidate();
+      updateDelta[key] = { type: "update" };
+    }
+    if (Object.keys(reverseUpdateOp.data).length !== 0) {
+      reverseOps.unshift(reverseUpdateOp);
+    }
+    if (Object.keys(updatedProps).length !== 0) {
+      ops.unshift({
+        opId,
+        id: this._id,
+        type: 3 /* UPDATE_OBJECT */,
+        data: updatedProps
+      });
     }
+    const storageUpdates = /* @__PURE__ */ new Map();
+    storageUpdates.set(this._id, {
+      node: this,
+      type: "LiveObject",
+      updates: updateDelta
+    });
+    this._pool.dispatch(ops, reverseOps, storageUpdates);
   }
-}
-function throwUsageError(message) {
-  if (process.env.NODE_ENV !== "production") {
-    const usageError = new Error(message);
-    usageError.name = "Usage error";
-    errorWithTitle("Usage error", message);
-    throw usageError;
+  toImmutable() {
+    return super.toImmutable();
   }
-}
-function errorIf(condition, message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (condition) {
-      throwUsageError(message);
+  _toImmutable() {
+    const result = {};
+    for (const [key, val] of this._map) {
+      result[key] = isLiveStructure(val) ? val.toImmutable() : val;
     }
+    return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
   }
-}
+};
 
-// src/EventSource.ts
+// src/lib/EventSource.ts
 function makeEventSource() {
   const _onetimeObservers = /* @__PURE__ */ new Set();
   const _observers = /* @__PURE__ */ new Set();
@@ -2447,7 +2414,39 @@ function makeEventSource() {
   };
 }
 
-// src/ImmutableRef.ts
+// src/lib/Json.ts
+function isJsonScalar(data) {
+  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+}
+function isJsonArray(data) {
+  return Array.isArray(data);
+}
+function isJsonObject(data) {
+  return !isJsonScalar(data) && !isJsonArray(data);
+}
+
+// src/protocol/ClientMsg.ts
+var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
+  ClientMsgCode2[ClientMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
+  ClientMsgCode2[ClientMsgCode2["BROADCAST_EVENT"] = 103] = "BROADCAST_EVENT";
+  ClientMsgCode2[ClientMsgCode2["FETCH_STORAGE"] = 200] = "FETCH_STORAGE";
+  ClientMsgCode2[ClientMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
+  return ClientMsgCode2;
+})(ClientMsgCode || {});
+
+// src/protocol/ServerMsg.ts
+var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
+  ServerMsgCode2[ServerMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
+  ServerMsgCode2[ServerMsgCode2["USER_JOINED"] = 101] = "USER_JOINED";
+  ServerMsgCode2[ServerMsgCode2["USER_LEFT"] = 102] = "USER_LEFT";
+  ServerMsgCode2[ServerMsgCode2["BROADCASTED_EVENT"] = 103] = "BROADCASTED_EVENT";
+  ServerMsgCode2[ServerMsgCode2["ROOM_STATE"] = 104] = "ROOM_STATE";
+  ServerMsgCode2[ServerMsgCode2["INITIAL_STORAGE_STATE"] = 200] = "INITIAL_STORAGE_STATE";
+  ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
+  return ServerMsgCode2;
+})(ServerMsgCode || {});
+
+// src/refs/ImmutableRef.ts
 function merge(target, patch) {
   let updated = false;
   const newValue = __spreadValues({}, target);
@@ -2484,7 +2483,7 @@ var ImmutableRef = class {
   }
 };
 
-// src/MeRef.ts
+// src/refs/MeRef.ts
 var MeRef = class extends ImmutableRef {
   constructor(initialPresence) {
     super();
@@ -2503,7 +2502,7 @@ var MeRef = class extends ImmutableRef {
   }
 };
 
-// src/LegacyArray.ts
+// src/lib/LegacyArray.ts
 function asArrayWithLegacyMethods(arr) {
   Object.defineProperty(arr, "count", {
     value: arr.length,
@@ -2516,7 +2515,7 @@ function asArrayWithLegacyMethods(arr) {
   return freeze(arr);
 }
 
-// src/OthersRef.ts
+// src/refs/OthersRef.ts
 function makeUser(conn, presence) {
   return freeze(compactObject(__spreadProps(__spreadValues({}, conn), { presence })));
 }
@@ -2602,18 +2601,7 @@ var OthersRef = class extends ImmutableRef {
   }
 };
 
-// src/types/Json.ts
-function isJsonScalar(data) {
-  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-}
-function isJsonArray(data) {
-  return Array.isArray(data);
-}
-function isJsonObject(data) {
-  return !isJsonScalar(data) && !isJsonArray(data);
-}
-
-// src/ValueRef.ts
+// src/refs/ValueRef.ts
 var ValueRef = class extends ImmutableRef {
   constructor(initialValue) {
     super();
@@ -2641,7 +2629,23 @@ var DerivedRef = class extends ImmutableRef {
   }
 };
 
+// src/types/WebsocketCloseCodes.ts
+var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+  return WebsocketCloseCodes2;
+})(WebsocketCloseCodes || {});
+
 // src/room.ts
+function isRoomEventName(value) {
+  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history";
+}
 var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
 var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
 var HEARTBEAT_INTERVAL = 3e4;
@@ -3793,7 +3797,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
   const ws = WebSocketPolyfill || WebSocket;
   return (token) => {
     return new ws(
-      `${liveblocksServer}/?token=${token}&version=${true ? "0.19.0-beta0" : "dev"}`
+      `${liveblocksServer}/?token=${token}&version=${true ? "0.19.0" : "dev"}`
     );
   };
 }
@@ -4311,7 +4315,7 @@ function legacy_patchImmutableNode(state, path, update) {
   }
 }
 
-// src/shallow.ts
+// src/lib/shallow.ts
 function shallowArray(xs, ys) {
   if (xs.length !== ys.length) {
     return false;