@liveblocks/client 0.16.12 → 0.16.13

package/shared.mjs

@@ -1,4 +1,39 @@
-var ServerMsgCode, ClientMsgCode, CrdtType, OpCode, WebsocketCloseCodes;
+const _emittedDeprecationWarnings = new Set;
+
+function deprecate(message, key = message) {
+ "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
+ console.error(`DEPRECATION WARNING: ${message}`)));
+}
+
+function deprecateIf(condition, message, key = message) {
+ "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
+}
+
+function throwUsageError(message) {
+ if ("production" !== process.env.NODE_ENV) {
+  const usageError = new Error(message);
+  throw usageError.name = "Usage error", usageError;
+ }
+}
+
+function errorIf(condition, message) {
+ "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
+}
+
+function assertNever(_value, errmsg) {
+ throw new Error(errmsg);
+}
+
+function nn(value, errmsg = "Expected value to be non-nullable") {
+ return function(condition, errmsg) {
+  if ("production" !== process.env.NODE_ENV && !condition) {
+   const err = new Error(errmsg);
+   throw err.name = "Assertion failure", err;
+  }
+ }(null != value, errmsg), value;
+}
+
+var ClientMsgCode, OpCode, CrdtType, ServerMsgCode, WebsocketCloseCodes, OpSource;
 
 function isRootCrdt(crdt) {
  return crdt.type === CrdtType.OBJECT && !isChildCrdt(crdt);
@@ -8,24 +43,32 @@ function isChildCrdt(crdt) {
  return void 0 !== crdt.parentId && void 0 !== crdt.parentKey;
 }
 
-!function(ServerMsgCode) {
- ServerMsgCode[ServerMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", ServerMsgCode[ServerMsgCode.USER_JOINED = 101] = "USER_JOINED", 
- ServerMsgCode[ServerMsgCode.USER_LEFT = 102] = "USER_LEFT", ServerMsgCode[ServerMsgCode.BROADCASTED_EVENT = 103] = "BROADCASTED_EVENT", 
- ServerMsgCode[ServerMsgCode.ROOM_STATE = 104] = "ROOM_STATE", ServerMsgCode[ServerMsgCode.INITIAL_STORAGE_STATE = 200] = "INITIAL_STORAGE_STATE", 
- ServerMsgCode[ServerMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE";
-}(ServerMsgCode || (ServerMsgCode = {})), function(ClientMsgCode) {
+function HasParent(node, key) {
+ return Object.freeze({
+  type: "HasParent",
+  node: node,
+  key: key
+ });
+}
+
+!function(ClientMsgCode) {
  ClientMsgCode[ClientMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", ClientMsgCode[ClientMsgCode.BROADCAST_EVENT = 103] = "BROADCAST_EVENT", 
  ClientMsgCode[ClientMsgCode.FETCH_STORAGE = 200] = "FETCH_STORAGE", ClientMsgCode[ClientMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE";
-}(ClientMsgCode || (ClientMsgCode = {})), function(CrdtType) {
- CrdtType[CrdtType.OBJECT = 0] = "OBJECT", CrdtType[CrdtType.LIST = 1] = "LIST", 
- CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER";
-}(CrdtType || (CrdtType = {})), function(OpCode) {
+}(ClientMsgCode || (ClientMsgCode = {})), function(OpCode) {
  OpCode[OpCode.INIT = 0] = "INIT", OpCode[OpCode.SET_PARENT_KEY = 1] = "SET_PARENT_KEY", 
  OpCode[OpCode.CREATE_LIST = 2] = "CREATE_LIST", OpCode[OpCode.UPDATE_OBJECT = 3] = "UPDATE_OBJECT", 
  OpCode[OpCode.CREATE_OBJECT = 4] = "CREATE_OBJECT", OpCode[OpCode.DELETE_CRDT = 5] = "DELETE_CRDT", 
  OpCode[OpCode.DELETE_OBJECT_KEY = 6] = "DELETE_OBJECT_KEY", OpCode[OpCode.CREATE_MAP = 7] = "CREATE_MAP", 
  OpCode[OpCode.CREATE_REGISTER = 8] = "CREATE_REGISTER";
-}(OpCode || (OpCode = {})), function(WebsocketCloseCodes) {
+}(OpCode || (OpCode = {})), function(CrdtType) {
+ CrdtType[CrdtType.OBJECT = 0] = "OBJECT", CrdtType[CrdtType.LIST = 1] = "LIST", 
+ CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER";
+}(CrdtType || (CrdtType = {})), function(ServerMsgCode) {
+ ServerMsgCode[ServerMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", ServerMsgCode[ServerMsgCode.USER_JOINED = 101] = "USER_JOINED", 
+ ServerMsgCode[ServerMsgCode.USER_LEFT = 102] = "USER_LEFT", ServerMsgCode[ServerMsgCode.BROADCASTED_EVENT = 103] = "BROADCASTED_EVENT", 
+ ServerMsgCode[ServerMsgCode.ROOM_STATE = 104] = "ROOM_STATE", ServerMsgCode[ServerMsgCode.INITIAL_STORAGE_STATE = 200] = "INITIAL_STORAGE_STATE", 
+ ServerMsgCode[ServerMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE";
+}(ServerMsgCode || (ServerMsgCode = {})), function(WebsocketCloseCodes) {
  WebsocketCloseCodes[WebsocketCloseCodes.CLOSE_ABNORMAL = 1006] = "CLOSE_ABNORMAL", 
  WebsocketCloseCodes[WebsocketCloseCodes.INVALID_MESSAGE_FORMAT = 4e3] = "INVALID_MESSAGE_FORMAT", 
  WebsocketCloseCodes[WebsocketCloseCodes.NOT_ALLOWED = 4001] = "NOT_ALLOWED", WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS", 
@@ -33,9 +76,41 @@ function isChildCrdt(crdt) {
  WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP", 
  WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM", 
  WebsocketCloseCodes[WebsocketCloseCodes.CLOSE_WITHOUT_RETRY = 4999] = "CLOSE_WITHOUT_RETRY";
-}(WebsocketCloseCodes || (WebsocketCloseCodes = {}));
+}(WebsocketCloseCodes || (WebsocketCloseCodes = {})), function(OpSource) {
+ OpSource[OpSource.UNDOREDO_RECONNECT = 0] = "UNDOREDO_RECONNECT", OpSource[OpSource.REMOTE = 1] = "REMOTE", 
+ OpSource[OpSource.ACK = 2] = "ACK";
+}(OpSource || (OpSource = {}));
+
+const NoParent = Object.freeze({
+ type: "NoParent"
+});
+
+function Orphaned(oldKey) {
+ return Object.freeze({
+  type: "Orphaned",
+  oldKey: oldKey
+ });
+}
 
 class AbstractCrdt {
+ constructor() {
+  this._parent = NoParent;
+ }
+ _getParentKeyOrThrow() {
+  switch (this.parent.type) {
+  case "HasParent":
+   return this.parent.key;
+
+  case "NoParent":
+   throw new Error("Parent key is missing");
+
+  case "Orphaned":
+   return this.parent.oldKey;
+
+  default:
+   return assertNever(this.parent, "Unknown state");
+  }
+ }
  get _doc() {
   return this.__doc;
  }
@@ -45,37 +120,79 @@ class AbstractCrdt {
  get _id() {
   return this.__id;
  }
- get _parent() {
-  return this.__parent;
+ get parent() {
+  return this._parent;
+ }
+ get _parentNode() {
+  switch (this.parent.type) {
+  case "HasParent":
+   return this.parent.node;
+
+  case "NoParent":
+  case "Orphaned":
+   return null;
+
+  default:
+   return assertNever(this.parent, "Unknown state");
+  }
  }
  get _parentKey() {
-  return this.__parentKey;
+  switch (this.parent.type) {
+  case "HasParent":
+   return this.parent.key;
+
+  case "NoParent":
+   return null;
+
+  case "Orphaned":
+   return this.parent.oldKey;
+
+  default:
+   return assertNever(this.parent, "Unknown state");
+  }
  }
  _apply(op, _isLocal) {
-  return op.type === OpCode.DELETE_CRDT && null != this._parent && null != this._parentKey ? this._parent._detachChild(this) : {
+  return op.type === OpCode.DELETE_CRDT && "HasParent" === this.parent.type ? this.parent.node._detachChild(this) : {
    modified: !1
   };
  }
- _setParentLink(parent, key) {
-  if (null != this.__parent && this.__parent !== parent) throw new Error("Cannot attach parent if it already exist");
-  this.__parentKey = key, this.__parent = parent;
+ _setParentLink(newParentNode, newParentKey) {
+  switch (this.parent.type) {
+  case "HasParent":
+   if (this.parent.node !== newParentNode) throw new Error("Cannot attach parent if it already exist");
+   return void (this._parent = HasParent(newParentNode, newParentKey));
+
+  case "Orphaned":
+  case "NoParent":
+   return void (this._parent = HasParent(newParentNode, newParentKey));
+
+  default:
+   return assertNever(this.parent, "Unknown state");
+  }
  }
  _attach(id, doc) {
   if (this.__id || this.__doc) throw new Error("Cannot attach if CRDT is already attached");
   doc.addItem(id, this), this.__id = id, this.__doc = doc;
  }
  _detach() {
-  this.__doc && this.__id && this.__doc.deleteItem(this.__id), this.__parent = void 0, 
-  this.__doc = void 0;
- }
-}
+  switch (this.__doc && this.__id && this.__doc.deleteItem(this.__id), this.parent.type) {
+  case "HasParent":
+   this._parent = Orphaned(this.parent.key);
+   break;
 
-function isJsonArray(data) {
- return Array.isArray(data);
-}
+  case "NoParent":
+   this._parent = NoParent;
+   break;
 
-function isJsonObject(data) {
- return null !== data && "object" == typeof data && !isJsonArray(data);
+  case "Orphaned":
+   this._parent = Orphaned(this.parent.oldKey);
+   break;
+
+  default:
+   assertNever(this.parent, "Unknown state");
+  }
+  this.__doc = void 0;
+ }
 }
 
 class LiveRegister extends AbstractCrdt {
@@ -89,28 +206,27 @@ class LiveRegister extends AbstractCrdt {
   const register = new LiveRegister(item.data);
   return register._attach(id, doc), register;
  }
- _serialize(parentId, parentKey, doc, intent) {
+ _serialize(parentId, parentKey, doc) {
   if (null == this._id || null == parentId || null == parentKey) throw new Error("Cannot serialize register if parentId or parentKey is undefined");
   return [ {
    type: OpCode.CREATE_REGISTER,
    opId: null == doc ? void 0 : doc.generateOpId(),
    id: this._id,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: this.data
   } ];
  }
  _toSerializedCrdt() {
-  var _a;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveRegister if parent is missing");
   return {
    type: CrdtType.REGISTER,
-   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
-   parentKey: this._parentKey,
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key,
    data: this.data
   };
  }
- _attachChild(_op, _isLocal) {
+ _attachChild(_op) {
   throw new Error("Method not implemented.");
  }
  _detachChild(_crdt) {
@@ -122,7 +238,7 @@ class LiveRegister extends AbstractCrdt {
 }
 
 function makePosition(before, after) {
- return null == before && null == after ? pos([ 33 ]) : null != before && null == after ? function(before) {
+ return null != before && null != after ? pos(makePositionFromCodes(posCodes(before), posCodes(after))) : null != before ? function(before) {
   const result = [], beforeCodes = posCodes(before);
   for (let i = 0; i < beforeCodes.length; i++) {
    const code = beforeCodes[i];
@@ -136,7 +252,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(before) : null == before && null != after ? function(after) {
+ }(before) : null != after ? function(after) {
   const result = [], afterCodes = posCodes(after);
   for (let i = 0; i < afterCodes.length; i++) {
    const code = afterCodes[i];
@@ -150,7 +266,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(after) : pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+ }(after) : pos([ 33 ]);
 }
 
 function makePositionFromCodes(before, after) {
@@ -196,114 +312,243 @@ function comparePosition(posA, posB) {
 class LiveList extends AbstractCrdt {
  constructor(items = []) {
   let position;
-  super(), this._items = [];
+  super(), this._items = [], this._implicitlyDeletedItems = new Set;
   for (let i = 0; i < items.length; i++) {
-   const newPosition = makePosition(position), item = selfOrRegister(items[i]);
-   this._items.push([ item, newPosition ]), position = newPosition;
+   const newPosition = makePosition(position), item = lsonToLiveNode(items[i]);
+   item._setParentLink(this, newPosition), this._items.push(item), position = newPosition;
   }
  }
  static _deserialize([id], parentToChildren, doc) {
-  const list = new LiveList([]);
+  const list = new LiveList;
   list._attach(id, doc);
   const children = parentToChildren.get(id);
   if (null == children) return list;
-  for (const entry of children) {
-   const child = deserialize(entry, parentToChildren, doc);
-   child._setParentLink(list, entry[1].parentKey), list._items.push([ child, entry[1].parentKey ]), 
-   list._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
+  for (const [id, crdt] of children) {
+   const child = deserialize([ id, crdt ], parentToChildren, doc);
+   child._setParentLink(list, crdt.parentKey), list._items.push(child), sortListItem(list._items);
   }
   return list;
  }
- _serialize(parentId, parentKey, doc, intent) {
+ _serialize(parentId, parentKey, doc) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
-  if (null == parentId || null == parentKey) throw new Error("Cannot serialize list if parentId or parentKey is undefined");
   const ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
-   intent: intent,
    type: OpCode.CREATE_LIST,
    parentId: parentId,
    parentKey: parentKey
   };
   ops.push(op);
-  for (const [value, key] of this._items) ops.push(...value._serialize(this._id, key, doc));
+  for (const item of this._items) ops.push(...item._serialize(this._id, item._getParentKeyOrThrow(), doc));
   return ops;
  }
  _indexOfPosition(position) {
-  return this._items.findIndex((item => item[1] === position));
+  return this._items.findIndex((item => item._getParentKeyOrThrow() === position));
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const [item] of this._items) item._attach(doc.generateId(), doc);
+  for (const item of this._items) item._attach(doc.generateId(), doc);
  }
  _detach() {
   super._detach();
-  for (const [value] of this._items) value._detach();
+  for (const item of this._items) item._detach();
  }
- _attachChild(op, isLocal) {
-  var _a;
+ _applyRemoteSet(op) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, parentKey: parentKey, intent: intent} = op, key = parentKey, child = creationOpToLiveStructure(op);
-  if (void 0 !== this._doc.getItem(id)) return {
-   modified: !1
-  };
+  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
   child._attach(id, this._doc), child._setParentLink(this, key);
-  const index = this._items.findIndex((entry => entry[1] === key));
-  let newKey = key;
-  if (-1 !== index) {
-   if ("set" === intent) {
-    const existingItem = this._items[index][0];
-    existingItem._detach();
-    const storageUpdate = {
-     node: this,
-     type: "LiveList",
-     updates: [ {
-      index: index,
-      type: "set",
-      item: child instanceof LiveRegister ? child.data : child
-     } ]
+  const deletedId = op.deletedId, existingItemIndex = this._indexOfPosition(key);
+  if (-1 !== existingItemIndex) {
+   const existingItem = this._items[existingItemIndex];
+   if (existingItem._id === deletedId) return existingItem._detach(), this._items[existingItemIndex] = child, 
+   {
+    modified: makeUpdate(this, [ setDelta(existingItemIndex, child) ]),
+    reverse: []
+   };
+   {
+    this._implicitlyDeletedItems.add(existingItem), this._items[existingItemIndex] = child;
+    const delta = [ setDelta(existingItemIndex, child) ], deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+    return deleteDelta && delta.push(deleteDelta), {
+     modified: makeUpdate(this, delta),
+     reverse: []
+    };
+   }
+  }
+  {
+   const updates = [], deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+   return deleteDelta && updates.push(deleteDelta), this._items.push(child), sortListItem(this._items), 
+   updates.push(insertDelta(this._indexOfPosition(key), child)), {
+    reverse: [],
+    modified: makeUpdate(this, updates)
+   };
+  }
+ }
+ _applySetAck(op) {
+  const delta = [], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+  deletedDelta && delta.push(deletedDelta);
+  const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey), existingItem = this._items.find((item => item._id === op.id));
+  if (null != existingItem) {
+   if (existingItem._parentKey === op.parentKey) return delta.length > 0 ? {
+    modified: makeUpdate(this, delta),
+    reverse: []
+   } : {
+    modified: !1
+   };
+   -1 !== indexOfItemWithSamePosition && (this._implicitlyDeletedItems.add(this._items[indexOfItemWithSamePosition]), 
+   this._items.splice(indexOfItemWithSamePosition, 1), delta.push(deleteDelta(indexOfItemWithSamePosition)));
+   const previousIndex = this._items.indexOf(existingItem);
+   existingItem._setParentLink(this, op.parentKey), sortListItem(this._items);
+   const newIndex = this._items.indexOf(existingItem);
+   return newIndex !== previousIndex && delta.push(moveDelta(previousIndex, newIndex, existingItem)), 
+   {
+    modified: delta.length > 0 && makeUpdate(this, delta),
+    reverse: []
+   };
+  }
+  {
+   const orphan = nn(this._doc).getItem(op.id);
+   if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+    orphan._setParentLink(this, op.parentKey), this._implicitlyDeletedItems.delete(orphan), 
+    this._items.push(orphan), sortListItem(this._items);
+    const recreatedItemIndex = this._items.indexOf(orphan);
+    return {
+     modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan), ...delta ]),
+     reverse: []
     };
-    return this._items[index][0] = child, {
-     modified: storageUpdate,
-     reverse: existingItem._serialize(this._id, key, this._doc, "set")
+   }
+   {
+    const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, op.parentKey);
+    return {
+     modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(newIndex, newItem) : setDelta(newIndex, newItem), ...delta ]),
+     reverse: []
     };
    }
-   if (isLocal) {
-    const before = this._items[index] ? this._items[index][1] : void 0, after = this._items[index + 1] ? this._items[index + 1][1] : void 0;
-    newKey = makePosition(before, after), child._setParentLink(this, newKey);
-   } else this._items[index][1] = makePosition(key, null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a[1]);
   }
-  this._items.push([ child, newKey ]), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
-  const newIndex = this._items.findIndex((entry => entry[1] === newKey));
+ }
+ _detachItemAssociatedToSetOperation(deletedId) {
+  if (null == deletedId || null == this._doc) return null;
+  const deletedItem = this._doc.getItem(deletedId);
+  if (null == deletedItem) return null;
+  const result = this._detachChild(deletedItem);
+  return !1 === result.modified ? null : result.modified.updates[0];
+ }
+ _applyRemoteInsert(op) {
+  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
+  const key = op.parentKey, existingItemIndex = this._indexOfPosition(key);
+  -1 !== existingItemIndex && this._shiftItemPosition(existingItemIndex, key);
+  const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, key);
   return {
+   modified: makeUpdate(this, [ insertDelta(newIndex, newItem) ]),
+   reverse: []
+  };
+ }
+ _applyInsertAck(op) {
+  const existingItem = this._items.find((item => item._id === op.id)), key = op.parentKey, itemIndexAtPosition = this._indexOfPosition(key);
+  if (existingItem) {
+   if (existingItem._parentKey === key) return {
+    modified: !1
+   };
+   {
+    const oldPositionIndex = this._items.indexOf(existingItem);
+    -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key), 
+    existingItem._setParentLink(this, key), sortListItem(this._items);
+    const newIndex = this._indexOfPosition(key);
+    return newIndex === oldPositionIndex ? {
+     modified: !1
+    } : {
+     modified: makeUpdate(this, [ moveDelta(oldPositionIndex, newIndex, existingItem) ]),
+     reverse: []
+    };
+   }
+  }
+  {
+   const orphan = nn(this._doc).getItem(op.id);
+   if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+    orphan._setParentLink(this, key), this._implicitlyDeletedItems.delete(orphan), this._items.push(orphan), 
+    sortListItem(this._items);
+    return {
+     modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(key), orphan) ]),
+     reverse: []
+    };
+   }
+   {
+    -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key);
+    const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, key);
+    return {
+     modified: makeUpdate(this, [ insertDelta(newIndex, newItem) ]),
+     reverse: []
+    };
+   }
+  }
+ }
+ _applyInsertUndoRedo(op) {
+  var _a;
+  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
+  if (void 0 !== (null === (_a = this._doc) || void 0 === _a ? void 0 : _a.getItem(id))) return {
+   modified: !1
+  };
+  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
+  const existingItemIndex = this._indexOfPosition(key);
+  let newKey = key;
+  if (-1 !== existingItemIndex) {
+   newKey = makePosition(this._items[existingItemIndex] ? this._items[existingItemIndex]._getParentKeyOrThrow() : void 0, this._items[existingItemIndex + 1] ? this._items[existingItemIndex + 1]._getParentKeyOrThrow() : void 0), 
+   child._setParentLink(this, newKey);
+  }
+  this._items.push(child), sortListItem(this._items);
+  return {
+   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(newKey), child) ]),
    reverse: [ {
     type: OpCode.DELETE_CRDT,
     id: id
-   } ],
-   modified: {
-    node: this,
-    type: "LiveList",
-    updates: [ {
-     index: newIndex,
-     type: "insert",
-     item: child instanceof LiveRegister ? child.data : child
-    } ]
-   }
+   } ]
   };
  }
+ _applySetUndoRedo(op) {
+  var _a;
+  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
+  if (void 0 !== (null === (_a = this._doc) || void 0 === _a ? void 0 : _a.getItem(id))) return {
+   modified: !1
+  };
+  const indexOfItemWithSameKey = this._indexOfPosition(key);
+  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
+  const newKey = key;
+  if (-1 !== indexOfItemWithSameKey) {
+   const existingItem = this._items[indexOfItemWithSameKey];
+   existingItem._detach(), this._items[indexOfItemWithSameKey] = child;
+   const reverse = existingItem._serialize(nn(this._id), key, this._doc);
+   addIntentAndDeletedIdToOperation(reverse, op.id);
+   const delta = [ setDelta(indexOfItemWithSameKey, child) ], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+   return deletedDelta && delta.push(deletedDelta), {
+    modified: makeUpdate(this, delta),
+    reverse: reverse
+   };
+  }
+  {
+   this._items.push(child), sortListItem(this._items), this._detachItemAssociatedToSetOperation(op.deletedId);
+   const newIndex = this._indexOfPosition(newKey);
+   return {
+    reverse: [ {
+     type: OpCode.DELETE_CRDT,
+     id: id
+    } ],
+    modified: makeUpdate(this, [ insertDelta(newIndex, child) ])
+   };
+  }
+ }
+ _attachChild(op, source) {
+  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
+  if ("set" === op.intent) {
+   if (source === OpSource.REMOTE) return this._applyRemoteSet(op);
+   if (source === OpSource.UNDOREDO_RECONNECT) return this._applySetUndoRedo(op);
+   if (source === OpSource.ACK) return this._applySetAck(op);
+  }
+  return source === OpSource.REMOTE ? this._applyRemoteInsert(op) : source === OpSource.ACK ? this._applyInsertAck(op) : this._applyInsertUndoRedo(op);
+ }
  _detachChild(child) {
   if (child) {
-   const reverse = child._serialize(this._id, child._parentKey, this._doc), indexToDelete = this._items.findIndex((item => item[0] === child));
-   this._items.splice(indexToDelete, 1), child._detach();
-   return {
-    modified: {
-     node: this,
-     type: "LiveList",
-     updates: [ {
-      index: indexToDelete,
-      type: "delete"
-     } ]
-    },
+   const parentKey = nn(child._parentKey), reverse = child._serialize(nn(this._id), parentKey, this._doc), indexToDelete = this._items.indexOf(child);
+   return this._items.splice(indexToDelete, 1), child._detach(), {
+    modified: makeUpdate(this, [ deleteDelta(indexToDelete) ]),
     reverse: reverse
    };
   }
@@ -311,41 +556,100 @@ class LiveList extends AbstractCrdt {
    modified: !1
   };
  }
- _setChildKey(key, child, previousKey) {
+ _applySetChildKeyRemote(newKey, child) {
   var _a;
-  child._setParentLink(this, key);
-  const previousIndex = this._items.findIndex((entry => entry[0]._id === child._id)), index = this._items.findIndex((entry => entry[1] === key));
-  -1 !== index && (this._items[index][1] = makePosition(key, null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a[1]));
-  const item = this._items.find((item => item[0] === child));
-  item && (item[1] = key), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
-  const newIndex = this._items.findIndex((entry => entry[0]._id === child._id));
-  return {
-   modified: {
-    node: this,
-    type: "LiveList",
-    updates: newIndex === previousIndex ? [] : [ {
-     index: newIndex,
-     item: child instanceof LiveRegister ? child.data : child,
-     previousIndex: previousIndex,
-     type: "move"
-    } ]
-   },
+  if (this._implicitlyDeletedItems.has(child)) {
+   this._implicitlyDeletedItems.delete(child), child._setParentLink(this, newKey), 
+   this._items.push(child), sortListItem(this._items);
+   return {
+    modified: makeUpdate(this, [ insertDelta(this._items.indexOf(child), child) ]),
+    reverse: []
+   };
+  }
+  if (newKey === child._parentKey) return {
+   modified: !1
+  };
+  const existingItemIndex = this._indexOfPosition(newKey);
+  if (-1 === existingItemIndex) {
+   const previousIndex = this._items.indexOf(child);
+   child._setParentLink(this, newKey), sortListItem(this._items);
+   const newIndex = this._items.indexOf(child);
+   return newIndex === previousIndex ? {
+    modified: !1
+   } : {
+    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+    reverse: []
+   };
+  }
+  {
+   this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow()));
+   const previousIndex = this._items.indexOf(child);
+   child._setParentLink(this, newKey), sortListItem(this._items);
+   const newIndex = this._items.indexOf(child);
+   return newIndex === previousIndex ? {
+    modified: !1
+   } : {
+    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+    reverse: []
+   };
+  }
+ }
+ _applySetChildKeyAck(newKey, child) {
+  var _a, _b;
+  const previousKey = nn(child._parentKey);
+  if (this._implicitlyDeletedItems.has(child)) {
+   const existingItemIndex = this._indexOfPosition(newKey);
+   return this._implicitlyDeletedItems.delete(child), -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow())), 
+   child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
+   {
+    modified: !1
+   };
+  }
+  {
+   if (newKey === previousKey) return {
+    modified: !1
+   };
+   const previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
+   -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_b = this._items[existingItemIndex + 1]) || void 0 === _b ? void 0 : _b._getParentKeyOrThrow())), 
+   child._setParentLink(this, newKey), sortListItem(this._items);
+   const newIndex = this._items.indexOf(child);
+   return previousIndex === newIndex ? {
+    modified: !1
+   } : {
+    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+    reverse: []
+   };
+  }
+ }
+ _applySetChildKeyUndoRedo(newKey, child) {
+  var _a;
+  const previousKey = nn(child._parentKey), previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
+  -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow())), 
+  child._setParentLink(this, newKey), sortListItem(this._items);
+  const newIndex = this._items.indexOf(child);
+  return previousIndex === newIndex ? {
+   modified: !1
+  } : {
+   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
    reverse: [ {
     type: OpCode.SET_PARENT_KEY,
-    id: null == item ? void 0 : item[0]._id,
+    id: nn(child._id),
     parentKey: previousKey
    } ]
   };
  }
+ _setChildKey(newKey, child, source) {
+  return source === OpSource.REMOTE ? this._applySetChildKeyRemote(newKey, child) : source === OpSource.ACK ? this._applySetChildKeyAck(newKey, child) : this._applySetChildKeyUndoRedo(newKey, child);
+ }
  _apply(op, isLocal) {
   return super._apply(op, isLocal);
  }
  _toSerializedCrdt() {
-  var _a;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveList if parent is missing");
   return {
    type: CrdtType.LIST,
-   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
-   parentKey: this._parentKey
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key
   };
  }
  get length() {
@@ -356,25 +660,14 @@ class LiveList extends AbstractCrdt {
  }
  insert(element, index) {
   if (index < 0 || index > this._items.length) throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`);
-  const position = makePosition(this._items[index - 1] ? this._items[index - 1][1] : void 0, this._items[index] ? this._items[index][1] : void 0), value = selfOrRegister(element);
-  value._setParentLink(this, position), this._items.push([ value, position ]), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
-  const newIndex = this._items.findIndex((entry => entry[1] === position));
-  if (this._doc && this._id) {
+  const position = makePosition(this._items[index - 1] ? this._items[index - 1]._getParentKeyOrThrow() : void 0, this._items[index] ? this._items[index]._getParentKeyOrThrow() : void 0), value = lsonToLiveNode(element);
+  if (value._setParentLink(this, position), this._items.push(value), sortListItem(this._items), 
+  this._doc && this._id) {
    const id = this._doc.generateId();
-   value._attach(id, this._doc);
-   const storageUpdates = new Map;
-   storageUpdates.set(this._id, {
-    node: this,
-    type: "LiveList",
-    updates: [ {
-     index: newIndex,
-     item: value instanceof LiveRegister ? value.data : value,
-     type: "insert"
-    } ]
-   }), this._doc.dispatch(value._serialize(this._id, position, this._doc), [ {
+   value._attach(id, this._doc), this._doc.dispatch(value._serialize(this._id, position, this._doc), [ {
     type: OpCode.DELETE_CRDT,
     id: id
-   } ], storageUpdates);
+   } ], new Map([ [ this._id, makeUpdate(this, [ insertDelta(index, value) ]) ] ]));
   }
  }
  move(index, targetIndex) {
@@ -383,31 +676,20 @@ class LiveList extends AbstractCrdt {
   if (index < 0) throw new Error("index cannot be less than 0");
   if (index >= this._items.length) throw new Error("index cannot be greater or equal than the list length");
   let beforePosition = null, afterPosition = null;
-  index < targetIndex ? (afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1][1], 
-  beforePosition = this._items[targetIndex][1]) : (afterPosition = this._items[targetIndex][1], 
-  beforePosition = 0 === targetIndex ? void 0 : this._items[targetIndex - 1][1]);
-  const position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item[1];
-  item[1] = position, item[0]._setParentLink(this, position), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
-  const newIndex = this._items.findIndex((entry => entry[1] === position));
-  if (this._doc && this._id) {
-   const storageUpdates = new Map;
-   storageUpdates.set(this._id, {
-    node: this,
-    type: "LiveList",
-    updates: [ {
-     index: newIndex,
-     previousIndex: index,
-     item: item[0],
-     type: "move"
-    } ]
-   }), this._doc.dispatch([ {
+  index < targetIndex ? (afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._getParentKeyOrThrow(), 
+  beforePosition = this._items[targetIndex]._getParentKeyOrThrow()) : (afterPosition = this._items[targetIndex]._getParentKeyOrThrow(), 
+  beforePosition = 0 === targetIndex ? void 0 : this._items[targetIndex - 1]._getParentKeyOrThrow());
+  const position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item._getParentKeyOrThrow();
+  if (item._setParentLink(this, position), sortListItem(this._items), this._doc && this._id) {
+   const storageUpdates = new Map([ [ this._id, makeUpdate(this, [ moveDelta(index, targetIndex, item) ]) ] ]);
+   this._doc.dispatch([ {
     type: OpCode.SET_PARENT_KEY,
-    id: item[0]._id,
+    id: nn(item._id),
     opId: this._doc.generateOpId(),
     parentKey: position
    } ], [ {
     type: OpCode.SET_PARENT_KEY,
-    id: item[0]._id,
+    id: nn(item._id),
     parentKey: previousPosition
    } ], storageUpdates);
   }
@@ -415,22 +697,15 @@ class LiveList extends AbstractCrdt {
  delete(index) {
   if (index < 0 || index >= this._items.length) throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
   const item = this._items[index];
-  if (item[0]._detach(), this._items.splice(index, 1), this._doc) {
-   const childRecordId = item[0]._id;
+  if (item._detach(), this._items.splice(index, 1), this._doc) {
+   const childRecordId = item._id;
    if (childRecordId) {
     const storageUpdates = new Map;
-    storageUpdates.set(this._id, {
-     node: this,
-     type: "LiveList",
-     updates: [ {
-      index: index,
-      type: "delete"
-     } ]
-    }), this._doc.dispatch([ {
+    storageUpdates.set(nn(this._id), makeUpdate(this, [ deleteDelta(index) ])), this._doc.dispatch([ {
      id: childRecordId,
      opId: this._doc.generateOpId(),
      type: OpCode.DELETE_CRDT
-    } ], item[0]._serialize(this._id, item[1]), storageUpdates);
+    } ], item._serialize(nn(this._id), item._getParentKeyOrThrow()), storageUpdates);
    }
   }
  }
@@ -439,50 +714,41 @@ class LiveList extends AbstractCrdt {
    const ops = [], reverseOps = [], updateDelta = [];
    let i = 0;
    for (const item of this._items) {
-    item[0]._detach();
-    const childId = item[0]._id;
+    item._detach();
+    const childId = item._id;
     childId && (ops.push({
+     type: OpCode.DELETE_CRDT,
      id: childId,
-     type: OpCode.DELETE_CRDT
-    }), reverseOps.push(...item[0]._serialize(this._id, item[1])), updateDelta.push({
-     index: i,
-     type: "delete"
-    })), i++;
+     opId: this._doc.generateOpId()
+    }), reverseOps.push(...item._serialize(nn(this._id), item._getParentKeyOrThrow())), 
+    updateDelta.push(deleteDelta(i))), i++;
    }
    this._items = [];
    const storageUpdates = new Map;
-   storageUpdates.set(this._id, {
-    node: this,
-    type: "LiveList",
-    updates: updateDelta
-   }), this._doc.dispatch(ops, reverseOps, storageUpdates);
+   storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta)), this._doc.dispatch(ops, reverseOps, storageUpdates);
   } else {
-   for (const item of this._items) item[0]._detach();
+   for (const item of this._items) item._detach();
    this._items = [];
   }
  }
  set(index, item) {
   if (index < 0 || index >= this._items.length) throw new Error(`Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
-  const [existingItem, position] = this._items[index];
+  const existingItem = this._items[index], position = existingItem._getParentKeyOrThrow(), existingId = existingItem._id;
   existingItem._detach();
-  const value = selfOrRegister(item);
-  if (value._setParentLink(this, position), this._items[index][0] = value, this._doc && this._id) {
+  const value = lsonToLiveNode(item);
+  if (value._setParentLink(this, position), this._items[index] = value, this._doc && this._id) {
    const id = this._doc.generateId();
    value._attach(id, this._doc);
    const storageUpdates = new Map;
-   storageUpdates.set(this._id, {
-    node: this,
-    type: "LiveList",
-    updates: [ {
-     index: index,
-     item: value instanceof LiveRegister ? value.data : value,
-     type: "set"
-    } ]
-   }), this._doc.dispatch(value._serialize(this._id, position, this._doc, "set"), existingItem._serialize(this._id, position, void 0, "set"), storageUpdates);
+   storageUpdates.set(this._id, makeUpdate(this, [ setDelta(index, value) ]));
+   const ops = value._serialize(this._id, position, this._doc);
+   addIntentAndDeletedIdToOperation(ops, existingId);
+   const reverseOps = existingItem._serialize(this._id, position, void 0);
+   addIntentAndDeletedIdToOperation(reverseOps, id), this._doc.dispatch(ops, reverseOps, storageUpdates);
   }
  }
  toArray() {
-  return this._items.map((entry => selfOrRegisterValue(entry[0])));
+  return this._items.map((entry => liveNodeToLson(entry)));
  }
  every(predicate) {
   return this.toArray().every(predicate);
@@ -500,7 +766,7 @@ class LiveList extends AbstractCrdt {
   return this.toArray().forEach(callbackfn);
  }
  get(index) {
-  if (!(index < 0 || index >= this._items.length)) return selfOrRegisterValue(this._items[index][0]);
+  if (!(index < 0 || index >= this._items.length)) return liveNodeToLson(this._items[index]);
  }
  indexOf(searchElement, fromIndex) {
   return this.toArray().indexOf(searchElement, fromIndex);
@@ -509,7 +775,7 @@ class LiveList extends AbstractCrdt {
   return this.toArray().lastIndexOf(searchElement, fromIndex);
  }
  map(callback) {
-  return this._items.map(((entry, i) => callback(selfOrRegisterValue(entry[0]), i)));
+  return this._items.map(((entry, i) => callback(liveNodeToLson(entry), i)));
  }
  some(predicate) {
   return this.toArray().some(predicate);
@@ -517,6 +783,20 @@ class LiveList extends AbstractCrdt {
  [Symbol.iterator]() {
   return new LiveListIterator(this._items);
  }
+ _createAttachItemAndSort(op, key) {
+  const newItem = creationOpToLiveNode(op);
+  newItem._attach(op.id, nn(this._doc)), newItem._setParentLink(this, key), this._items.push(newItem), 
+  sortListItem(this._items);
+  return {
+   newItem: newItem,
+   newIndex: this._indexOfPosition(key)
+  };
+ }
+ _shiftItemPosition(index, key) {
+  var _a;
+  const shiftedPosition = makePosition(key, this._items.length > index + 1 ? null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow() : void 0);
+  this._items[index]._setParentLink(this, shiftedPosition);
+ }
 }
 
 class LiveListIterator {
@@ -528,57 +808,85 @@ class LiveListIterator {
  }
  next() {
   const result = this._innerIterator.next();
-  return result.done ? {
+  if (result.done) return {
    done: !0,
    value: void 0
-  } : {
-   value: selfOrRegisterValue(result.value[0])
+  };
+  return {
+   value: liveNodeToLson(result.value)
   };
  }
 }
 
-const _emittedDeprecationWarnings = new Set;
+function makeUpdate(liveList, deltaUpdates) {
+ return {
+  node: liveList,
+  type: "LiveList",
+  updates: deltaUpdates
+ };
+}
 
-function deprecate(message, key = message) {
- "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
- console.error(`DEPRECATION WARNING: ${message}`)));
+function setDelta(index, item) {
+ return {
+  index: index,
+  type: "set",
+  item: item instanceof LiveRegister ? item.data : item
+ };
 }
 
-function deprecateIf(condition, message, key = message) {
- "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
+function deleteDelta(index) {
+ return {
+  index: index,
+  type: "delete"
+ };
 }
 
-function throwUsageError(message) {
- if ("production" !== process.env.NODE_ENV) {
-  const usageError = new Error(message);
-  throw usageError.name = "Usage error", usageError;
- }
+function insertDelta(index, item) {
+ return {
+  index: index,
+  type: "insert",
+  item: item instanceof LiveRegister ? item.data : item
+ };
 }
 
-function errorIf(condition, message) {
- "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
+function moveDelta(previousIndex, index, item) {
+ return {
+  index: index,
+  type: "move",
+  previousIndex: previousIndex,
+  item: item instanceof LiveRegister ? item.data : item
+ };
+}
+
+function sortListItem(items) {
+ items.sort(((itemA, itemB) => comparePosition(itemA._getParentKeyOrThrow(), itemB._getParentKeyOrThrow())));
+}
+
+function addIntentAndDeletedIdToOperation(ops, deletedId) {
+ if (0 === ops.length) throw new Error("Internal error. Serialized LiveStructure should have at least 1 operation");
+ const firstOp = ops[0];
+ if (firstOp.type !== OpCode.CREATE_LIST && firstOp.type !== OpCode.CREATE_OBJECT && firstOp.type !== OpCode.CREATE_REGISTER && firstOp.type !== OpCode.CREATE_MAP) throw new Error("Internal error. Serialized LiveStructure first op should be CreateOp");
+ firstOp.intent = "set", firstOp.deletedId = deletedId;
 }
 
 class LiveMap extends AbstractCrdt {
  constructor(entries) {
-  if (super(), deprecateIf(null === entries, "Support for calling `new LiveMap(null)` will be removed in @liveblocks/client 0.18. Please call as `new LiveMap()`, or `new LiveMap([])`."), 
+  if (super(), errorIf(null === entries, "Support for calling `new LiveMap(null)` will be removed in @liveblocks/client 0.18. Please call as `new LiveMap()`, or `new LiveMap([])`."), 
   entries) {
    const mappedEntries = [];
    for (const entry of entries) {
-    const value = selfOrRegister(entry[1]);
+    const value = lsonToLiveNode(entry[1]);
     value._setParentLink(this, entry[0]), mappedEntries.push([ entry[0], value ]);
    }
    this._map = new Map(mappedEntries);
   } else this._map = new Map;
  }
- _serialize(parentId, parentKey, doc, intent) {
+ _serialize(parentId, parentKey, doc) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
-  if (null == parentId || null == parentKey) throw new Error("Cannot serialize map if parentId or parentKey is undefined");
   const ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
    type: OpCode.CREATE_MAP,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey
   };
@@ -591,30 +899,32 @@ class LiveMap extends AbstractCrdt {
   map._attach(id, doc);
   const children = parentToChildren.get(id);
   if (null == children) return map;
-  for (const entry of children) {
-   const crdt = entry[1];
-   if (null == crdt.parentKey) throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
-   const child = deserialize(entry, parentToChildren, doc);
+  for (const [id, crdt] of children) {
+   const child = deserialize([ id, crdt ], parentToChildren, doc);
    child._setParentLink(map, crdt.parentKey), map._map.set(crdt.parentKey, child);
   }
   return map;
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const [_key, value] of this._map) isCrdt(value) && value._attach(doc.generateId(), doc);
+  for (const [_key, value] of this._map) isLiveNode(value) && value._attach(doc.generateId(), doc);
  }
- _attachChild(op, _isLocal) {
+ _attachChild(op) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, parentKey: parentKey} = op, key = parentKey, child = creationOpToLiveStructure(op);
+  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
   if (void 0 !== this._doc.getItem(id)) return {
    modified: !1
   };
   const previousValue = this._map.get(key);
   let reverse;
-  return previousValue ? (reverse = previousValue._serialize(this._id, key), previousValue._detach()) : reverse = [ {
+  if (previousValue) {
+   const thisId = nn(this._id);
+   reverse = previousValue._serialize(thisId, key), previousValue._detach();
+  } else reverse = [ {
    type: OpCode.DELETE_CRDT,
    id: id
-  } ], child._setParentLink(this, key), child._attach(id, this._doc), this._map.set(key, child), 
+  } ];
+  return child._setParentLink(this, key), child._attach(id, this._doc), this._map.set(key, child), 
   {
    modified: {
     node: this,
@@ -633,7 +943,7 @@ class LiveMap extends AbstractCrdt {
   for (const item of this._map.values()) item._detach();
  }
  _detachChild(child) {
-  const reverse = child._serialize(this._id, child._parentKey, this._doc);
+  const id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc);
   for (const [key, value] of this._map) value === child && this._map.delete(key);
   child._detach();
   return {
@@ -641,7 +951,7 @@ class LiveMap extends AbstractCrdt {
     node: this,
     type: "LiveMap",
     updates: {
-     [child._parentKey]: {
+     [parentKey]: {
       type: "delete"
      }
     }
@@ -650,21 +960,21 @@ class LiveMap extends AbstractCrdt {
   };
  }
  _toSerializedCrdt() {
-  var _a;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveMap if parent is missing");
   return {
    type: CrdtType.MAP,
-   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
-   parentKey: this._parentKey
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key
   };
  }
  get(key) {
   const value = this._map.get(key);
-  if (null != value) return selfOrRegisterValue(value);
+  if (null != value) return liveNodeToLson(value);
  }
  set(key, value) {
   const oldValue = this._map.get(key);
   oldValue && oldValue._detach();
-  const item = selfOrRegister(value);
+  const item = lsonToLiveNode(value);
   if (item._setParentLink(this, key), this._map.set(key, item), this._doc && this._id) {
    const id = this._doc.generateId();
    item._attach(id, this._doc);
@@ -693,8 +1003,8 @@ class LiveMap extends AbstractCrdt {
   const item = this._map.get(key);
   if (null == item) return !1;
   if (item._detach(), this._map.delete(key), this._doc && item._id) {
-   const storageUpdates = new Map;
-   storageUpdates.set(this._id, {
+   const thisId = nn(this._id), storageUpdates = new Map;
+   storageUpdates.set(thisId, {
     node: this,
     type: "LiveMap",
     updates: {
@@ -706,14 +1016,14 @@ class LiveMap extends AbstractCrdt {
     type: OpCode.DELETE_CRDT,
     id: item._id,
     opId: this._doc.generateOpId()
-   } ], item._serialize(this._id, key), storageUpdates);
+   } ], item._serialize(thisId, key), storageUpdates);
   }
   return !0;
  }
  entries() {
   const innerIterator = this._map.entries();
   return {
-   [Symbol.iterator]: function() {
+   [Symbol.iterator]() {
     return this;
    },
    next() {
@@ -723,7 +1033,7 @@ class LiveMap extends AbstractCrdt {
      value: void 0
     };
     return {
-     value: [ iteratorValue.value[0], selfOrRegisterValue(iteratorValue.value[1]) ]
+     value: [ iteratorValue.value[0], liveNodeToLson(iteratorValue.value[1]) ]
     };
    }
   };
@@ -737,16 +1047,17 @@ class LiveMap extends AbstractCrdt {
  values() {
   const innerIterator = this._map.values();
   return {
-   [Symbol.iterator]: function() {
+   [Symbol.iterator]() {
     return this;
    },
    next() {
     const iteratorValue = innerIterator.next();
-    return iteratorValue.done ? {
+    if (iteratorValue.done) return {
      done: !0,
      value: void 0
-    } : {
-     value: selfOrRegisterValue(iteratorValue.value)
+    };
+    return {
+     value: liveNodeToLson(iteratorValue.value)
     };
    }
   };
@@ -756,8 +1067,12 @@ class LiveMap extends AbstractCrdt {
  }
 }
 
-function assertNever(_value, errmsg) {
- throw new Error(errmsg);
+function isJsonArray(data) {
+ return Array.isArray(data);
+}
+
+function isJsonObject(data) {
+ return null !== data && "object" == typeof data && !isJsonArray(data);
 }
 
 function remove(array, item) {
@@ -771,7 +1086,7 @@ function compact(items) {
  return items.filter((item => null != item));
 }
 
-function creationOpToLiveStructure(op) {
+function creationOpToLiveNode(op) {
  switch (op.type) {
  case OpCode.CREATE_REGISTER:
   return new LiveRegister(op.data);
@@ -784,11 +1099,14 @@ function creationOpToLiveStructure(op) {
 
  case OpCode.CREATE_LIST:
   return new LiveList;
+
+ default:
+  return assertNever(0, "Unknown creation Op");
  }
 }
 
 function isSameNodeOrChildOf(node, parent) {
- return node === parent || !!node._parent && isSameNodeOrChildOf(node._parent, parent);
+ return node === parent || "HasParent" === node.parent.type && isSameNodeOrChildOf(node.parent.node, parent);
 }
 
 function deserialize([id, crdt], parentToChildren, doc) {
@@ -810,18 +1128,28 @@ function deserialize([id, crdt], parentToChildren, doc) {
  }
 }
 
-function isCrdt(obj) {
- return obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList || obj instanceof LiveRegister;
+function isLiveNode(value) {
+ return isLiveList(value) || function(value) {
+  return value instanceof LiveMap;
+ }(value) || isLiveObject(value) || function(value) {
+  return value instanceof LiveRegister;
+ }(value);
+}
+
+function isLiveList(value) {
+ return value instanceof LiveList;
+}
+
+function isLiveObject(value) {
+ return value instanceof LiveObject;
 }
 
-function selfOrRegisterValue(obj) {
- return obj instanceof LiveRegister ? obj.data : obj;
+function liveNodeToLson(obj) {
+ return obj instanceof LiveRegister ? obj.data : obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject ? obj : assertNever(0, "Unknown AbstractCrdt");
 }
 
-function selfOrRegister(obj) {
- if (obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList) return obj;
- if (obj instanceof LiveRegister) throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
- return new LiveRegister(obj);
+function lsonToLiveNode(value) {
+ return value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList ? value : new LiveRegister(value);
 }
 
 function getTreesDiffOperations(currentItems, newItems) {
@@ -840,7 +1168,7 @@ function getTreesDiffOperations(currentItems, newItems) {
   })), crdt.parentKey !== currentCrdt.parentKey && ops.push({
    type: OpCode.SET_PARENT_KEY,
    id: id,
-   parentKey: crdt.parentKey
+   parentKey: nn(crdt.parentKey, "Parent key must not be missing")
   }); else switch (crdt.type) {
   case CrdtType.REGISTER:
    ops.push({
@@ -975,17 +1303,16 @@ class LiveObject extends AbstractCrdt {
   super(), this._propToLastUpdate = new Map;
   for (const key in obj) {
    const value = obj[key];
-   value instanceof AbstractCrdt && value._setParentLink(this, key);
+   isLiveNode(value) && value._setParentLink(this, key);
   }
   this._map = new Map(Object.entries(obj));
  }
- _serialize(parentId, parentKey, doc, intent) {
+ _serialize(parentId, parentKey, doc) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
   const opId = null == doc ? void 0 : doc.generateOpId(), ops = [], op = void 0 !== parentId && void 0 !== parentKey ? {
    type: OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: {}
@@ -993,11 +1320,10 @@ class LiveObject extends AbstractCrdt {
    type: OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
-   intent: intent,
    data: {}
   };
   ops.push(op);
-  for (const [key, value] of this._map) value instanceof AbstractCrdt ? ops.push(...value._serialize(this._id, key, doc)) : op.data[key] = value;
+  for (const [key, value] of this._map) isLiveNode(value) ? ops.push(...value._serialize(this._id, key, doc)) : op.data[key] = value;
   return ops;
  }
  static _deserialize([id, item], parentToChildren, doc) {
@@ -1005,43 +1331,41 @@ class LiveObject extends AbstractCrdt {
   return liveObj._attach(id, doc), this._deserializeChildren(liveObj, parentToChildren, doc);
  }
  static _deserializeChildren(liveObj, parentToChildren, doc) {
-  const children = parentToChildren.get(liveObj._id);
+  const children = parentToChildren.get(nn(liveObj._id));
   if (null == children) return liveObj;
-  for (const entry of children) {
-   const crdt = entry[1];
-   if (null == crdt.parentKey) throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
-   const child = deserialize(entry, parentToChildren, doc);
+  for (const [id, crdt] of children) {
+   const child = deserialize([ id, crdt ], parentToChildren, doc);
    child._setParentLink(liveObj, crdt.parentKey), liveObj._map.set(crdt.parentKey, child);
   }
   return liveObj;
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const [_key, value] of this._map) value instanceof AbstractCrdt && value._attach(doc.generateId(), doc);
+  for (const [_key, value] of this._map) isLiveNode(value) && value._attach(doc.generateId(), doc);
  }
- _attachChild(op, isLocal) {
+ _attachChild(op, source) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, parentKey: parentKey, opId: opId} = op, key = parentKey, child = creationOpToLiveStructure(op);
+  const {id: id, opId: opId, parentKey: key} = op, child = creationOpToLiveNode(op);
   if (void 0 !== this._doc.getItem(id)) return this._propToLastUpdate.get(key) === opId && this._propToLastUpdate.delete(key), 
   {
    modified: !1
   };
-  if (isLocal) this._propToLastUpdate.set(key, opId); else if (void 0 !== this._propToLastUpdate.get(key)) return this._propToLastUpdate.get(key) === opId ? (this._propToLastUpdate.delete(key), 
+  if (source === OpSource.UNDOREDO_RECONNECT) this._propToLastUpdate.set(key, nn(opId)); else if (void 0 !== this._propToLastUpdate.get(key)) return this._propToLastUpdate.get(key) === opId ? (this._propToLastUpdate.delete(key), 
   {
    modified: !1
   }) : {
    modified: !1
   };
-  const previousValue = this._map.get(key);
+  const thisId = nn(this._id), previousValue = this._map.get(key);
   let reverse;
-  return isCrdt(previousValue) ? (reverse = previousValue._serialize(this._id, key), 
+  return isLiveNode(previousValue) ? (reverse = previousValue._serialize(thisId, key), 
   previousValue._detach()) : reverse = void 0 === previousValue ? [ {
    type: OpCode.DELETE_OBJECT_KEY,
-   id: this._id,
+   id: thisId,
    key: key
   } ] : [ {
    type: OpCode.UPDATE_OBJECT,
-   id: this._id,
+   id: thisId,
    data: {
     [key]: previousValue
    }
@@ -1061,7 +1385,7 @@ class LiveObject extends AbstractCrdt {
  }
  _detachChild(child) {
   if (child) {
-   const reverse = child._serialize(this._id, child._parentKey, this._doc);
+   const id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc);
    for (const [key, value] of this._map) value === child && this._map.delete(key);
    child._detach();
    return {
@@ -1069,7 +1393,7 @@ class LiveObject extends AbstractCrdt {
      node: this,
      type: "LiveObject",
      updates: {
-      [child._parentKey]: {
+      [parentKey]: {
        type: "delete"
       }
      }
@@ -1081,24 +1405,20 @@ class LiveObject extends AbstractCrdt {
    modified: !1
   };
  }
- _detachChildren() {
-  for (const [key, value] of this._map) this._map.delete(key), value._detach();
- }
  _detach() {
   super._detach();
-  for (const value of this._map.values()) isCrdt(value) && value._detach();
+  for (const value of this._map.values()) isLiveNode(value) && value._detach();
  }
  _apply(op, isLocal) {
   return op.type === OpCode.UPDATE_OBJECT ? this._applyUpdate(op, isLocal) : op.type === OpCode.DELETE_OBJECT_KEY ? this._applyDeleteObjectKey(op) : super._apply(op, isLocal);
  }
  _toSerializedCrdt() {
-  var _a;
   const data = {};
-  for (const [key, value] of this._map) value instanceof AbstractCrdt == !1 && (data[key] = value);
-  return void 0 !== (null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id) && void 0 !== this._parentKey ? {
+  for (const [key, value] of this._map) isLiveNode(value) || (data[key] = value);
+  return "HasParent" === this.parent.type && this.parent.node._id ? {
    type: CrdtType.OBJECT,
-   parentId: this._parent._id,
-   parentKey: this._parentKey,
+   parentId: this.parent.node._id,
+   parentKey: this.parent.key,
    data: data
   } : {
    type: CrdtType.OBJECT,
@@ -1107,24 +1427,23 @@ class LiveObject extends AbstractCrdt {
  }
  _applyUpdate(op, isLocal) {
   let isModified = !1;
-  const reverse = [], reverseUpdate = {
+  const id = nn(this._id), reverse = [], reverseUpdate = {
    type: OpCode.UPDATE_OBJECT,
-   id: this._id,
+   id: id,
    data: {}
   };
   reverse.push(reverseUpdate);
   for (const key in op.data) {
    const oldValue = this._map.get(key);
-   oldValue instanceof AbstractCrdt ? (reverse.push(...oldValue._serialize(this._id, key)), 
-   oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
+   isLiveNode(oldValue) ? (reverse.push(...oldValue._serialize(id, key)), oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
     type: OpCode.DELETE_OBJECT_KEY,
-    id: this._id,
+    id: id,
     key: key
    });
   }
   const updateDelta = {};
   for (const key in op.data) {
-   if (isLocal) this._propToLastUpdate.set(key, op.opId); else {
+   if (isLocal) this._propToLastUpdate.set(key, nn(op.opId)); else {
     if (null != this._propToLastUpdate.get(key)) {
      if (this._propToLastUpdate.get(key) === op.opId) {
       this._propToLastUpdate.delete(key);
@@ -1135,7 +1454,7 @@ class LiveObject extends AbstractCrdt {
     isModified = !0;
    }
    const oldValue = this._map.get(key);
-   isCrdt(oldValue) && oldValue._detach(), isModified = !0, updateDelta[key] = {
+   isLiveNode(oldValue) && oldValue._detach(), isModified = !0, updateDelta[key] = {
     type: "update"
    }, this._map.set(key, op.data[key]);
   }
@@ -1159,11 +1478,11 @@ class LiveObject extends AbstractCrdt {
   if (void 0 !== this._propToLastUpdate.get(key)) return {
    modified: !1
   };
-  const oldValue = this._map.get(key);
+  const oldValue = this._map.get(key), id = nn(this._id);
   let reverse = [];
-  return isCrdt(oldValue) ? (reverse = oldValue._serialize(this._id, op.key), oldValue._detach()) : void 0 !== oldValue && (reverse = [ {
+  return isLiveNode(oldValue) ? (reverse = oldValue._serialize(id, op.key), oldValue._detach()) : void 0 !== oldValue && (reverse = [ {
    type: OpCode.UPDATE_OBJECT,
-   id: this._id,
+   id: id,
    data: {
     [key]: oldValue
    }
@@ -1198,10 +1517,10 @@ class LiveObject extends AbstractCrdt {
  delete(key) {
   const keyAsString = key, oldValue = this._map.get(keyAsString);
   if (void 0 === oldValue) return;
-  if (null == this._doc || null == this._id) return oldValue instanceof AbstractCrdt && oldValue._detach(), 
+  if (null == this._doc || null == this._id) return isLiveNode(oldValue) && oldValue._detach(), 
   void this._map.delete(keyAsString);
   let reverse;
-  oldValue instanceof AbstractCrdt ? (oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString)) : reverse = [ {
+  isLiveNode(oldValue) ? (oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString)) : reverse = [ {
    type: OpCode.UPDATE_OBJECT,
    data: {
     [keyAsString]: oldValue
@@ -1228,9 +1547,9 @@ class LiveObject extends AbstractCrdt {
   if (null == this._doc || null == this._id) {
    for (const key in overrides) {
     const oldValue = this._map.get(key);
-    oldValue instanceof AbstractCrdt && oldValue._detach();
+    isLiveNode(oldValue) && oldValue._detach();
     const newValue = overrides[key];
-    newValue instanceof AbstractCrdt && newValue._setParentLink(this, key), this._map.set(key, newValue);
+    isLiveNode(newValue) && newValue._setParentLink(this, key), this._map.set(key, newValue);
    }
    return;
   }
@@ -1241,17 +1560,17 @@ class LiveObject extends AbstractCrdt {
   }, updateDelta = {};
   for (const key in overrides) {
    const oldValue = this._map.get(key);
-   oldValue instanceof AbstractCrdt ? (reverseOps.push(...oldValue._serialize(this._id, key)), 
+   isLiveNode(oldValue) ? (reverseOps.push(...oldValue._serialize(this._id, key)), 
    oldValue._detach()) : void 0 === oldValue ? reverseOps.push({
     type: OpCode.DELETE_OBJECT_KEY,
     id: this._id,
     key: key
    }) : reverseUpdateOp.data[key] = oldValue;
    const newValue = overrides[key];
-   if (newValue instanceof AbstractCrdt) {
+   if (isLiveNode(newValue)) {
     newValue._setParentLink(this, key), newValue._attach(this._doc.generateId(), this._doc);
     const newAttachChildOps = newValue._serialize(this._id, key, this._doc), createCrdtOp = newAttachChildOps.find((op => op.parentId === this._id));
-    createCrdtOp && this._propToLastUpdate.set(key, createCrdtOp.opId), ops.push(...newAttachChildOps);
+    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), updateDelta[key] = {
     type: "update"
@@ -1273,4 +1592,4 @@ class LiveObject extends AbstractCrdt {
  }
 }
 
-export { AbstractCrdt as A, ClientMsgCode as C, LiveObject as L, OpCode as O, ServerMsgCode as S, WebsocketCloseCodes as W, isSameNodeOrChildOf as a, LiveList as b, isJsonArray as c, compact as d, isJsonObject as e, isRootCrdt as f, getTreesDiffOperations as g, deprecateIf as h, isTokenValid as i, LiveMap as j, LiveRegister as k, findNonSerializableValue as l, mergeStorageUpdates as m, deprecate as n, errorIf as o, throwUsageError as p, CrdtType as q, remove as r, comparePosition as s, tryParseJson as t, makePosition as u, isChildCrdt as v, assertNever as w, b64decode as x };
+export { makePosition as A, CrdtType as B, ClientMsgCode as C, isChildCrdt as D, LiveObject as L, OpSource as O, ServerMsgCode as S, WebsocketCloseCodes as W, isTokenValid as a, isSameNodeOrChildOf as b, OpCode as c, isLiveList as d, isJsonArray as e, compact as f, getTreesDiffOperations as g, b64decode as h, isLiveNode as i, isJsonObject as j, isRootCrdt as k, errorIf as l, mergeStorageUpdates as m, nn as n, LiveList as o, LiveMap as p, LiveRegister as q, remove as r, findNonSerializableValue as s, tryParseJson as t, isLiveObject as u, assertNever as v, deprecate as w, deprecateIf as x, throwUsageError as y, comparePosition as z };