@liveblocks/client 0.16.12 → 0.16.13

package/shared.js

@@ -122,52 +122,141 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-var ServerMsgCode, ClientMsgCode, CrdtType, OpCode, WebsocketCloseCodes;
+var ClientMsgCode, OpCode, CrdtType, ServerMsgCode, WebsocketCloseCodes, OpSource, _emittedDeprecationWarnings = new Set;
+
+function deprecate(message, key) {
+ void 0 === key && (key = message), "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
+ console.error("DEPRECATION WARNING: " + message)));
+}
+
+function throwUsageError(message) {
+ if ("production" !== process.env.NODE_ENV) {
+  var 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) {
+ return void 0 === errmsg && (errmsg = "Expected value to be non-nullable"), function(condition, errmsg) {
+  if ("production" !== process.env.NODE_ENV && !condition) {
+   var err = new Error(errmsg);
+   throw err.name = "Assertion failure", err;
+  }
+ }(null != value, errmsg), value;
+}
 
 function isChildCrdt(crdt) {
  return void 0 !== crdt.parentId && void 0 !== crdt.parentKey;
 }
 
+function HasParent(node, key) {
+ return Object.freeze({
+  type: "HasParent",
+  node: node,
+  key: key
+ });
+}
+
+exports.ClientMsgCode = void 0, (ClientMsgCode = exports.ClientMsgCode || (exports.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", exports.OpCode = void 0, 
+(OpCode = exports.OpCode || (exports.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", exports.CrdtType = void 0, 
+(CrdtType = exports.CrdtType || (exports.CrdtType = {}))[CrdtType.OBJECT = 0] = "OBJECT", 
+CrdtType[CrdtType.LIST = 1] = "LIST", CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER", 
 exports.ServerMsgCode = void 0, (ServerMsgCode = exports.ServerMsgCode || (exports.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", exports.ClientMsgCode = void 0, 
-(ClientMsgCode = exports.ClientMsgCode || (exports.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", exports.CrdtType = void 0, 
-(CrdtType = exports.CrdtType || (exports.CrdtType = {}))[CrdtType.OBJECT = 0] = "OBJECT", 
-CrdtType[CrdtType.LIST = 1] = "LIST", CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER", 
-exports.OpCode = void 0, (OpCode = exports.OpCode || (exports.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", 
-exports.WebsocketCloseCodes = void 0, (WebsocketCloseCodes = exports.WebsocketCloseCodes || (exports.WebsocketCloseCodes = {}))[WebsocketCloseCodes.CLOSE_ABNORMAL = 1006] = "CLOSE_ABNORMAL", 
+ServerMsgCode[ServerMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE", exports.WebsocketCloseCodes = void 0, 
+(WebsocketCloseCodes = exports.WebsocketCloseCodes || (exports.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", 
 WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS", 
 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.CLOSE_WITHOUT_RETRY = 4999] = "CLOSE_WITHOUT_RETRY", 
+exports.OpSource = void 0, (OpSource = exports.OpSource || (exports.OpSource = {}))[OpSource.UNDOREDO_RECONNECT = 0] = "UNDOREDO_RECONNECT", 
+OpSource[OpSource.REMOTE = 1] = "REMOTE", OpSource[OpSource.ACK = 2] = "ACK";
+
+var NoParent = Object.freeze({
+ type: "NoParent"
+});
+
+function Orphaned(oldKey) {
+ return Object.freeze({
+  type: "Orphaned",
+  oldKey: oldKey
+ });
+}
 
-var AbstractCrdt = function() {
+var _Symbol$iterator$1, _Symbol$iterator2, AbstractCrdt = function() {
  function AbstractCrdt() {
-  this.__parent = void 0, this.__doc = void 0, this.__id = void 0, this.__parentKey = void 0;
+  this.__doc = void 0, this.__id = void 0, this._parent = NoParent;
  }
  var _proto = AbstractCrdt.prototype;
- return _proto._apply = function(op, _isLocal) {
-  return op.type === exports.OpCode.DELETE_CRDT && null != this._parent && null != this._parentKey ? this._parent._detachChild(this) : {
+ return _proto._getParentKeyOrThrow = function() {
+  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");
+  }
+ }, _proto._apply = function(op, _isLocal) {
+  return op.type === exports.OpCode.DELETE_CRDT && "HasParent" === this.parent.type ? this.parent.node._detachChild(this) : {
    modified: !1
   };
- }, _proto._setParentLink = function(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;
+ }, _proto._setParentLink = function(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");
+  }
  }, _proto._attach = function(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;
  }, _proto._detach = function() {
-  this.__doc && this.__id && this.__doc.deleteItem(this.__id), this.__parent = void 0, 
+  switch (this.__doc && this.__id && this.__doc.deleteItem(this.__id), this.parent.type) {
+  case "HasParent":
+   this._parent = Orphaned(this.parent.key);
+   break;
+
+  case "NoParent":
+   this._parent = NoParent;
+   break;
+
+  case "Orphaned":
+   this._parent = Orphaned(this.parent.oldKey);
+   break;
+
+  default:
+   assertNever(this.parent, "Unknown state");
+  }
   this.__doc = void 0;
  }, _createClass(AbstractCrdt, [ {
   key: "_doc",
@@ -185,27 +274,44 @@ var AbstractCrdt = function() {
    return this.__id;
   }
  }, {
-  key: "_parent",
+  key: "parent",
   get: function() {
-   return this.__parent;
+   return this._parent;
   }
  }, {
-  key: "_parentKey",
+  key: "_parentNode",
   get: function() {
-   return this.__parentKey;
+   switch (this.parent.type) {
+   case "HasParent":
+    return this.parent.node;
+
+   case "NoParent":
+   case "Orphaned":
+    return null;
+
+   default:
+    return assertNever(this.parent, "Unknown state");
+   }
   }
- } ]), AbstractCrdt;
-}();
+ }, {
+  key: "_parentKey",
+  get: function() {
+   switch (this.parent.type) {
+   case "HasParent":
+    return this.parent.key;
 
-function isJsonArray(data) {
- return Array.isArray(data);
-}
+   case "NoParent":
+    return null;
 
-function isJsonObject(data) {
- return null !== data && "object" == typeof data && !isJsonArray(data);
-}
+   case "Orphaned":
+    return this.parent.oldKey;
 
-var _Symbol$iterator$1, _Symbol$iterator2, LiveRegister = function(_AbstractCrdt) {
+   default:
+    return assertNever(this.parent, "Unknown state");
+   }
+  }
+ } ]), AbstractCrdt;
+}(), LiveRegister = function(_AbstractCrdt) {
  function LiveRegister(data) {
   var _this;
   return (_this = _AbstractCrdt.call(this) || this)._data = void 0, _this._data = data, 
@@ -216,26 +322,25 @@ var _Symbol$iterator$1, _Symbol$iterator2, LiveRegister = function(_AbstractCrdt
   return register._attach(id, doc), register;
  };
  var _proto = LiveRegister.prototype;
- return _proto._serialize = function(parentId, parentKey, doc, intent) {
+ return _proto._serialize = function(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: exports.OpCode.CREATE_REGISTER,
    opId: null == doc ? void 0 : doc.generateOpId(),
    id: this._id,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: this.data
   } ];
  }, _proto._toSerializedCrdt = function() {
-  var _this$_parent;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveRegister if parent is missing");
   return {
    type: exports.CrdtType.REGISTER,
-   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
-   parentKey: this._parentKey,
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key,
    data: this.data
   };
- }, _proto._attachChild = function(_op, _isLocal) {
+ }, _proto._attachChild = function(_op) {
   throw new Error("Method not implemented.");
  }, _proto._detachChild = function(_crdt) {
   throw new Error("Method not implemented.");
@@ -250,7 +355,7 @@ var _Symbol$iterator$1, _Symbol$iterator2, LiveRegister = function(_AbstractCrdt
 }(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) {
   for (var result = [], beforeCodes = posCodes(before), i = 0; i < beforeCodes.length; i++) {
    var code = beforeCodes[i];
    if (126 !== code) {
@@ -263,7 +368,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(before) : null == before && null != after ? function(after) {
+ }(before) : null != after ? function(after) {
   for (var result = [], afterCodes = posCodes(after), i = 0; i < afterCodes.length; i++) {
    var code = afterCodes[i];
    if (!(code <= 33)) {
@@ -276,7 +381,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(after) : pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+ }(after) : pos([ 33 ]);
 }
 
 function makePositionFromCodes(before, after) {
@@ -320,206 +425,322 @@ var LiveList = function(_AbstractCrdt) {
  function LiveList(items) {
   var _this;
   void 0 === items && (items = []), (_this = _AbstractCrdt.call(this) || this)._items = void 0, 
-  _this._items = [];
+  _this._implicitlyDeletedItems = void 0, _this._items = [], _this._implicitlyDeletedItems = new Set;
   for (var position = void 0, i = 0; i < items.length; i++) {
-   var newPosition = makePosition(position), item = selfOrRegister(items[i]);
-   _this._items.push([ item, newPosition ]), position = newPosition;
+   var newPosition = makePosition(position), item = lsonToLiveNode(items[i]);
+   item._setParentLink(_assertThisInitialized(_this), newPosition), _this._items.push(item), 
+   position = newPosition;
   }
   return _this;
  }
  _inheritsLoose(LiveList, _AbstractCrdt), LiveList._deserialize = function(_ref, parentToChildren, doc) {
-  var id = _ref[0], list = new LiveList([]);
+  var id = _ref[0], list = new LiveList;
   list._attach(id, doc);
   var children = parentToChildren.get(id);
   if (null == children) return list;
   for (var _step, _iterator = _createForOfIteratorHelperLoose(children); !(_step = _iterator()).done; ) {
-   var entry = _step.value, child = deserialize(entry, parentToChildren, doc);
-   child._setParentLink(list, entry[1].parentKey), list._items.push([ child, entry[1].parentKey ]), 
-   list._items.sort((function(itemA, itemB) {
-    return comparePosition(itemA[1], itemB[1]);
-   }));
+   var _step$value = _step.value, _id = _step$value[0], crdt = _step$value[1], child = deserialize([ _id, crdt ], parentToChildren, doc);
+   child._setParentLink(list, crdt.parentKey), list._items.push(child), sortListItem(list._items);
   }
   return list;
  };
  var _proto = LiveList.prototype;
- return _proto._serialize = function(parentId, parentKey, doc, intent) {
+ return _proto._serialize = function(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");
   var ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
-   intent: intent,
    type: exports.OpCode.CREATE_LIST,
    parentId: parentId,
    parentKey: parentKey
   };
   ops.push(op);
   for (var _step2, _iterator2 = _createForOfIteratorHelperLoose(this._items); !(_step2 = _iterator2()).done; ) {
-   var _step2$value = _step2.value, _value = _step2$value[0], key = _step2$value[1];
-   ops.push.apply(ops, _value._serialize(this._id, key, doc));
+   var item = _step2.value;
+   ops.push.apply(ops, item._serialize(this._id, item._getParentKeyOrThrow(), doc));
   }
   return ops;
  }, _proto._indexOfPosition = function(position) {
   return this._items.findIndex((function(item) {
-   return item[1] === position;
+   return item._getParentKeyOrThrow() === position;
   }));
  }, _proto._attach = function(id, doc) {
   _AbstractCrdt.prototype._attach.call(this, id, doc);
   for (var _step3, _iterator3 = _createForOfIteratorHelperLoose(this._items); !(_step3 = _iterator3()).done; ) {
-   _step3.value[0]._attach(doc.generateId(), doc);
+   _step3.value._attach(doc.generateId(), doc);
   }
  }, _proto._detach = function() {
   _AbstractCrdt.prototype._detach.call(this);
   for (var _step4, _iterator4 = _createForOfIteratorHelperLoose(this._items); !(_step4 = _iterator4()).done; ) {
-   _step4.value[0]._detach();
+   _step4.value._detach();
   }
- }, _proto._attachChild = function(op, isLocal) {
+ }, _proto._applyRemoteSet = function(op) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, parentKey = op.parentKey, intent = op.intent, key = parentKey, child = creationOpToLiveStructure(op);
-  if (void 0 !== this._doc.getItem(id)) return {
-   modified: !1
-  };
+  var id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
   child._attach(id, this._doc), child._setParentLink(this, key);
-  var index = this._items.findIndex((function(entry) {
-   return entry[1] === key;
-  })), newKey = key;
-  if (-1 !== index) {
-   if ("set" === intent) {
-    var existingItem = this._items[index][0];
-    existingItem._detach();
-    var storageUpdate = {
-     node: this,
-     type: "LiveList",
-     updates: [ {
-      index: index,
-      type: "set",
-      item: child instanceof LiveRegister ? child.data : child
-     } ]
-    };
-    return this._items[index][0] = child, {
-     modified: storageUpdate,
-     reverse: existingItem._serialize(this._id, key, this._doc, "set")
-    };
-   }
-   if (isLocal) {
-    var 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 {
-    var _this$_items;
-    this._items[index][1] = makePosition(key, null == (_this$_items = this._items[index + 1]) ? void 0 : _this$_items[1]);
-   }
+  var deletedId = op.deletedId, existingItemIndex = this._indexOfPosition(key);
+  if (-1 !== existingItemIndex) {
+   var 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;
+   var delta = [ setDelta(existingItemIndex, child) ], _deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+   return _deleteDelta && delta.push(_deleteDelta), {
+    modified: makeUpdate(this, delta),
+    reverse: []
+   };
   }
-  this._items.push([ child, newKey ]), this._items.sort((function(itemA, itemB) {
-   return comparePosition(itemA[1], itemB[1]);
-  }));
-  var newIndex = this._items.findIndex((function(entry) {
-   return entry[1] === newKey;
+  var updates = [], _deleteDelta2 = this._detachItemAssociatedToSetOperation(op.deletedId);
+  return _deleteDelta2 && updates.push(_deleteDelta2), this._items.push(child), sortListItem(this._items), 
+  updates.push(insertDelta(this._indexOfPosition(key), child)), {
+   reverse: [],
+   modified: makeUpdate(this, updates)
+  };
+ }, _proto._applySetAck = function(op) {
+  var delta = [], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+  deletedDelta && delta.push(deletedDelta);
+  var indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey), existingItem = this._items.find((function(item) {
+   return 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)));
+   var previousIndex = this._items.indexOf(existingItem);
+   existingItem._setParentLink(this, op.parentKey), sortListItem(this._items);
+   var newIndex = this._items.indexOf(existingItem);
+   return newIndex !== previousIndex && delta.push(moveDelta(previousIndex, newIndex, existingItem)), 
+   {
+    modified: delta.length > 0 && makeUpdate(this, delta),
+    reverse: []
+   };
+  }
+  var 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);
+   var recreatedItemIndex = this._items.indexOf(orphan);
+   return {
+    modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan) ].concat(delta)),
+    reverse: []
+   };
+  }
+  var _this$_createAttachIt = this._createAttachItemAndSort(op, op.parentKey), newItem = _this$_createAttachIt.newItem, _newIndex = _this$_createAttachIt.newIndex;
+  return {
+   modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(_newIndex, newItem) : setDelta(_newIndex, newItem) ].concat(delta)),
+   reverse: []
+  };
+ }, _proto._detachItemAssociatedToSetOperation = function(deletedId) {
+  if (null == deletedId || null == this._doc) return null;
+  var deletedItem = this._doc.getItem(deletedId);
+  if (null == deletedItem) return null;
+  var result = this._detachChild(deletedItem);
+  return !1 === result.modified ? null : result.modified.updates[0];
+ }, _proto._applyRemoteInsert = function(op) {
+  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
+  var key = op.parentKey, existingItemIndex = this._indexOfPosition(key);
+  -1 !== existingItemIndex && this._shiftItemPosition(existingItemIndex, key);
+  var _this$_createAttachIt2 = this._createAttachItemAndSort(op, key), newItem = _this$_createAttachIt2.newItem;
+  return {
+   modified: makeUpdate(this, [ insertDelta(_this$_createAttachIt2.newIndex, newItem) ]),
+   reverse: []
+  };
+ }, _proto._applyInsertAck = function(op) {
+  var existingItem = this._items.find((function(item) {
+   return item._id === op.id;
+  })), key = op.parentKey, itemIndexAtPosition = this._indexOfPosition(key);
+  if (existingItem) {
+   if (existingItem._parentKey === key) return {
+    modified: !1
+   };
+   var oldPositionIndex = this._items.indexOf(existingItem);
+   -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key), 
+   existingItem._setParentLink(this, key), sortListItem(this._items);
+   var newIndex = this._indexOfPosition(key);
+   return newIndex === oldPositionIndex ? {
+    modified: !1
+   } : {
+    modified: makeUpdate(this, [ moveDelta(oldPositionIndex, newIndex, existingItem) ]),
+    reverse: []
+   };
+  }
+  var orphan = nn(this._doc).getItem(op.id);
+  if (orphan && this._implicitlyDeletedItems.has(orphan)) return orphan._setParentLink(this, key), 
+  this._implicitlyDeletedItems.delete(orphan), this._items.push(orphan), sortListItem(this._items), 
+  {
+   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(key), orphan) ]),
+   reverse: []
+  };
+  -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key);
+  var _this$_createAttachIt3 = this._createAttachItemAndSort(op, key), newItem = _this$_createAttachIt3.newItem;
+  return {
+   modified: makeUpdate(this, [ insertDelta(_this$_createAttachIt3.newIndex, newItem) ]),
+   reverse: []
+  };
+ }, _proto._applyInsertUndoRedo = function(op) {
+  var _this$_doc, id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
+  if (void 0 !== (null == (_this$_doc = this._doc) ? void 0 : _this$_doc.getItem(id))) return {
+   modified: !1
+  };
+  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
+  var existingItemIndex = this._indexOfPosition(key), newKey = key;
+  -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));
+  return this._items.push(child), sortListItem(this._items), {
+   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(newKey), child) ]),
+   reverse: [ {
+    type: exports.OpCode.DELETE_CRDT,
+    id: id
+   } ]
+  };
+ }, _proto._applySetUndoRedo = function(op) {
+  var _this$_doc2, id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
+  if (void 0 !== (null == (_this$_doc2 = this._doc) ? void 0 : _this$_doc2.getItem(id))) return {
+   modified: !1
+  };
+  var indexOfItemWithSameKey = this._indexOfPosition(key);
+  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
+  var newKey = key;
+  if (-1 !== indexOfItemWithSameKey) {
+   var existingItem = this._items[indexOfItemWithSameKey];
+   existingItem._detach(), this._items[indexOfItemWithSameKey] = child;
+   var reverse = existingItem._serialize(nn(this._id), key, this._doc);
+   addIntentAndDeletedIdToOperation(reverse, op.id);
+   var 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);
+  var newIndex = this._indexOfPosition(newKey);
   return {
    reverse: [ {
     type: exports.OpCode.DELETE_CRDT,
     id: id
    } ],
-   modified: {
-    node: this,
-    type: "LiveList",
-    updates: [ {
-     index: newIndex,
-     type: "insert",
-     item: child instanceof LiveRegister ? child.data : child
-    } ]
-   }
+   modified: makeUpdate(this, [ insertDelta(newIndex, child) ])
   };
+ }, _proto._attachChild = function(op, source) {
+  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
+  if ("set" === op.intent) {
+   if (source === exports.OpSource.REMOTE) return this._applyRemoteSet(op);
+   if (source === exports.OpSource.UNDOREDO_RECONNECT) return this._applySetUndoRedo(op);
+   if (source === exports.OpSource.ACK) return this._applySetAck(op);
+  }
+  return source === exports.OpSource.REMOTE ? this._applyRemoteInsert(op) : source === exports.OpSource.ACK ? this._applyInsertAck(op) : this._applyInsertUndoRedo(op);
  }, _proto._detachChild = function(child) {
   if (child) {
-   var reverse = child._serialize(this._id, child._parentKey, this._doc), indexToDelete = this._items.findIndex((function(item) {
-    return item[0] === child;
-   }));
+   var 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: {
-     node: this,
-     type: "LiveList",
-     updates: [ {
-      index: indexToDelete,
-      type: "delete"
-     } ]
-    },
+    modified: makeUpdate(this, [ deleteDelta(indexToDelete) ]),
     reverse: reverse
    };
   }
   return {
    modified: !1
   };
- }, _proto._setChildKey = function(key, child, previousKey) {
-  child._setParentLink(this, key);
-  var _this$_items2, previousIndex = this._items.findIndex((function(entry) {
-   return entry[0]._id === child._id;
-  })), index = this._items.findIndex((function(entry) {
-   return entry[1] === key;
-  }));
-  -1 !== index && (this._items[index][1] = makePosition(key, null == (_this$_items2 = this._items[index + 1]) ? void 0 : _this$_items2[1]));
-  var item = this._items.find((function(item) {
-   return item[0] === child;
-  }));
-  item && (item[1] = key), this._items.sort((function(itemA, itemB) {
-   return comparePosition(itemA[1], itemB[1]);
-  }));
-  var newIndex = this._items.findIndex((function(entry) {
-   return 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"
-    } ]
-   },
+ }, _proto._applySetChildKeyRemote = function(newKey, child) {
+  if (this._implicitlyDeletedItems.has(child)) return this._implicitlyDeletedItems.delete(child), 
+  child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
+  {
+   modified: makeUpdate(this, [ insertDelta(this._items.indexOf(child), child) ]),
+   reverse: []
+  };
+  if (newKey === child._parentKey) return {
+   modified: !1
+  };
+  var _this$_items, existingItemIndex = this._indexOfPosition(newKey);
+  if (-1 === existingItemIndex) {
+   var previousIndex = this._items.indexOf(child);
+   child._setParentLink(this, newKey), sortListItem(this._items);
+   var _newIndex4 = this._items.indexOf(child);
+   return _newIndex4 === previousIndex ? {
+    modified: !1
+   } : {
+    modified: makeUpdate(this, [ moveDelta(previousIndex, _newIndex4, child) ]),
+    reverse: []
+   };
+  }
+  this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items = this._items[existingItemIndex + 1]) ? void 0 : _this$_items._getParentKeyOrThrow()));
+  var _previousIndex = this._items.indexOf(child);
+  child._setParentLink(this, newKey), sortListItem(this._items);
+  var _newIndex5 = this._items.indexOf(child);
+  return _newIndex5 === _previousIndex ? {
+   modified: !1
+  } : {
+   modified: makeUpdate(this, [ moveDelta(_previousIndex, _newIndex5, child) ]),
+   reverse: []
+  };
+ }, _proto._applySetChildKeyAck = function(newKey, child) {
+  var previousKey = nn(child._parentKey);
+  if (this._implicitlyDeletedItems.has(child)) {
+   var _this$_items2, existingItemIndex = this._indexOfPosition(newKey);
+   if (this._implicitlyDeletedItems.delete(child), -1 !== existingItemIndex) this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items2 = this._items[existingItemIndex + 1]) ? void 0 : _this$_items2._getParentKeyOrThrow()));
+   return child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
+   {
+    modified: !1
+   };
+  }
+  if (newKey === previousKey) return {
+   modified: !1
+  };
+  var _this$_items3, previousIndex = this._items.indexOf(child), _existingItemIndex = this._indexOfPosition(newKey);
+  -1 !== _existingItemIndex && this._items[_existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items3 = this._items[_existingItemIndex + 1]) ? void 0 : _this$_items3._getParentKeyOrThrow())), 
+  child._setParentLink(this, newKey), sortListItem(this._items);
+  var newIndex = this._items.indexOf(child);
+  return previousIndex === newIndex ? {
+   modified: !1
+  } : {
+   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+   reverse: []
+  };
+ }, _proto._applySetChildKeyUndoRedo = function(newKey, child) {
+  var _this$_items4, previousKey = nn(child._parentKey), previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
+  -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items4 = this._items[existingItemIndex + 1]) ? void 0 : _this$_items4._getParentKeyOrThrow()));
+  child._setParentLink(this, newKey), sortListItem(this._items);
+  var newIndex = this._items.indexOf(child);
+  return previousIndex === newIndex ? {
+   modified: !1
+  } : {
+   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
    reverse: [ {
     type: exports.OpCode.SET_PARENT_KEY,
-    id: null == item ? void 0 : item[0]._id,
+    id: nn(child._id),
     parentKey: previousKey
    } ]
   };
+ }, _proto._setChildKey = function(newKey, child, source) {
+  return source === exports.OpSource.REMOTE ? this._applySetChildKeyRemote(newKey, child) : source === exports.OpSource.ACK ? this._applySetChildKeyAck(newKey, child) : this._applySetChildKeyUndoRedo(newKey, child);
  }, _proto._apply = function(op, isLocal) {
   return _AbstractCrdt.prototype._apply.call(this, op, isLocal);
  }, _proto._toSerializedCrdt = function() {
-  var _this$_parent;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveList if parent is missing");
   return {
    type: exports.CrdtType.LIST,
-   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
-   parentKey: this._parentKey
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key
   };
  }, _proto.push = function(element) {
   return this.insert(element, this.length);
  }, _proto.insert = function(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);
-  var 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((function(itemA, itemB) {
-   return comparePosition(itemA[1], itemB[1]);
-  }));
-  var newIndex = this._items.findIndex((function(entry) {
-   return entry[1] === position;
-  }));
-  if (this._doc && this._id) {
+  var 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) {
    var id = this._doc.generateId();
-   value._attach(id, this._doc);
-   var 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: exports.OpCode.DELETE_CRDT,
     id: id
-   } ], storageUpdates);
+   } ], new Map([ [ this._id, makeUpdate(this, [ insertDelta(index, value) ]) ] ]));
   }
  }, _proto.move = function(index, targetIndex) {
   if (targetIndex < 0) throw new Error("targetIndex cannot be less than 0");
@@ -527,108 +748,77 @@ var LiveList = function(_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");
   var 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]);
-  var position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item[1];
-  item[1] = position, item[0]._setParentLink(this, position), this._items.sort((function(itemA, itemB) {
-   return comparePosition(itemA[1], itemB[1]);
-  }));
-  var newIndex = this._items.findIndex((function(entry) {
-   return entry[1] === position;
-  }));
-  if (this._doc && this._id) {
-   var 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());
+  var position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item._getParentKeyOrThrow();
+  if (item._setParentLink(this, position), sortListItem(this._items), this._doc && this._id) {
+   var storageUpdates = new Map([ [ this._id, makeUpdate(this, [ moveDelta(index, targetIndex, item) ]) ] ]);
+   this._doc.dispatch([ {
     type: exports.OpCode.SET_PARENT_KEY,
-    id: item[0]._id,
+    id: nn(item._id),
     opId: this._doc.generateOpId(),
     parentKey: position
    } ], [ {
     type: exports.OpCode.SET_PARENT_KEY,
-    id: item[0]._id,
+    id: nn(item._id),
     parentKey: previousPosition
    } ], storageUpdates);
   }
  }, _proto.delete = function(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));
   var item = this._items[index];
-  if (item[0]._detach(), this._items.splice(index, 1), this._doc) {
-   var childRecordId = item[0]._id;
+  if (item._detach(), this._items.splice(index, 1), this._doc) {
+   var childRecordId = item._id;
    if (childRecordId) {
     var 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: exports.OpCode.DELETE_CRDT
-    } ], item[0]._serialize(this._id, item[1]), storageUpdates);
+    } ], item._serialize(nn(this._id), item._getParentKeyOrThrow()), storageUpdates);
    }
   }
  }, _proto.clear = function() {
   if (this._doc) {
    for (var _step5, ops = [], reverseOps = [], updateDelta = [], i = 0, _iterator5 = _createForOfIteratorHelperLoose(this._items); !(_step5 = _iterator5()).done; ) {
     var item = _step5.value;
-    item[0]._detach();
-    var childId = item[0]._id;
+    item._detach();
+    var childId = item._id;
     childId && (ops.push({
+     type: exports.OpCode.DELETE_CRDT,
      id: childId,
-     type: exports.OpCode.DELETE_CRDT
-    }), reverseOps.push.apply(reverseOps, item[0]._serialize(this._id, item[1])), updateDelta.push({
-     index: i,
-     type: "delete"
-    })), i++;
+     opId: this._doc.generateOpId()
+    }), reverseOps.push.apply(reverseOps, item._serialize(nn(this._id), item._getParentKeyOrThrow())), 
+    updateDelta.push(deleteDelta(i))), i++;
    }
    this._items = [];
    var 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 (var _step6, _iterator6 = _createForOfIteratorHelperLoose(this._items); !(_step6 = _iterator6()).done; ) {
-    _step6.value[0]._detach();
+    _step6.value._detach();
    }
    this._items = [];
   }
  }, _proto.set = function(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));
-  var _this$_items$index = this._items[index], existingItem = _this$_items$index[0], position = _this$_items$index[1];
+  var existingItem = this._items[index], position = existingItem._getParentKeyOrThrow(), existingId = existingItem._id;
   existingItem._detach();
-  var value = selfOrRegister(item);
-  if (value._setParentLink(this, position), this._items[index][0] = value, this._doc && this._id) {
+  var value = lsonToLiveNode(item);
+  if (value._setParentLink(this, position), this._items[index] = value, this._doc && this._id) {
    var id = this._doc.generateId();
    value._attach(id, this._doc);
    var 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) ]));
+   var ops = value._serialize(this._id, position, this._doc);
+   addIntentAndDeletedIdToOperation(ops, existingId);
+   var reverseOps = existingItem._serialize(this._id, position, void 0);
+   addIntentAndDeletedIdToOperation(reverseOps, id), this._doc.dispatch(ops, reverseOps, storageUpdates);
   }
  }, _proto.toArray = function() {
   return this._items.map((function(entry) {
-   return selfOrRegisterValue(entry[0]);
+   return liveNodeToLson(entry);
   }));
  }, _proto.every = function(predicate) {
   return this.toArray().every(predicate);
@@ -641,19 +831,29 @@ var LiveList = function(_AbstractCrdt) {
  }, _proto.forEach = function(callbackfn) {
   return this.toArray().forEach(callbackfn);
  }, _proto.get = function(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]);
  }, _proto.indexOf = function(searchElement, fromIndex) {
   return this.toArray().indexOf(searchElement, fromIndex);
  }, _proto.lastIndexOf = function(searchElement, fromIndex) {
   return this.toArray().lastIndexOf(searchElement, fromIndex);
  }, _proto.map = function(callback) {
   return this._items.map((function(entry, i) {
-   return callback(selfOrRegisterValue(entry[0]), i);
+   return callback(liveNodeToLson(entry), i);
   }));
  }, _proto.some = function(predicate) {
   return this.toArray().some(predicate);
  }, _proto[_Symbol$iterator$1] = function() {
   return new LiveListIterator(this._items);
+ }, _proto._createAttachItemAndSort = function(op, key) {
+  var newItem = creationOpToLiveNode(op);
+  return newItem._attach(op.id, nn(this._doc)), newItem._setParentLink(this, key), 
+  this._items.push(newItem), sortListItem(this._items), {
+   newItem: newItem,
+   newIndex: this._indexOfPosition(key)
+  };
+ }, _proto._shiftItemPosition = function(index, key) {
+  var _this$_items5, shiftedPosition = makePosition(key, this._items.length > index + 1 ? null == (_this$_items5 = this._items[index + 1]) ? void 0 : _this$_items5._getParentKeyOrThrow() : void 0);
+  this._items[index]._setParentLink(this, shiftedPosition);
  }, _createClass(LiveList, [ {
   key: "length",
   get: function() {
@@ -677,25 +877,62 @@ var _Symbol$iterator, LiveListIterator = function() {
    done: !0,
    value: void 0
   } : {
-   value: selfOrRegisterValue(result.value[0])
+   value: liveNodeToLson(result.value)
   };
  }, LiveListIterator;
-}(), _emittedDeprecationWarnings = new Set;
+}();
 
-function deprecate(message, key) {
- void 0 === key && (key = message), "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
- console.error("DEPRECATION WARNING: " + message)));
+function makeUpdate(liveList, deltaUpdates) {
+ return {
+  node: liveList,
+  type: "LiveList",
+  updates: deltaUpdates
+ };
 }
 
-function deprecateIf(condition, message, key) {
- void 0 === key && (key = message), "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
+function setDelta(index, item) {
+ return {
+  index: index,
+  type: "set",
+  item: item instanceof LiveRegister ? item.data : item
+ };
 }
 
-function throwUsageError(message) {
- if ("production" !== process.env.NODE_ENV) {
-  var usageError = new Error(message);
-  throw usageError.name = "Usage error", usageError;
- }
+function deleteDelta(index) {
+ return {
+  index: index,
+  type: "delete"
+ };
+}
+
+function insertDelta(index, item) {
+ return {
+  index: index,
+  type: "insert",
+  item: item instanceof LiveRegister ? item.data : item
+ };
+}
+
+function moveDelta(previousIndex, index, item) {
+ return {
+  index: index,
+  type: "move",
+  previousIndex: previousIndex,
+  item: item instanceof LiveRegister ? item.data : item
+ };
+}
+
+function sortListItem(items) {
+ items.sort((function(itemA, itemB) {
+  return 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");
+ var firstOp = ops[0];
+ if (firstOp.type !== exports.OpCode.CREATE_LIST && firstOp.type !== exports.OpCode.CREATE_OBJECT && firstOp.type !== exports.OpCode.CREATE_REGISTER && firstOp.type !== exports.OpCode.CREATE_MAP) throw new Error("Internal error. Serialized LiveStructure first op should be CreateOp");
+ firstOp.intent = "set", firstOp.deletedId = deletedId;
 }
 
 _Symbol$iterator = Symbol.iterator;
@@ -703,10 +940,10 @@ _Symbol$iterator = Symbol.iterator;
 var LiveMap = function(_AbstractCrdt) {
  function LiveMap(entries) {
   var _this;
-  if ((_this = _AbstractCrdt.call(this) || this)._map = void 0, 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 ((_this = _AbstractCrdt.call(this) || this)._map = void 0, 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) {
    for (var _step, mappedEntries = [], _iterator = _createForOfIteratorHelperLoose(entries); !(_step = _iterator()).done; ) {
-    var entry = _step.value, _value = selfOrRegister(entry[1]);
+    var entry = _step.value, _value = lsonToLiveNode(entry[1]);
     _value._setParentLink(_assertThisInitialized(_this), entry[0]), mappedEntries.push([ entry[0], _value ]);
    }
    _this._map = new Map(mappedEntries);
@@ -715,14 +952,12 @@ var LiveMap = function(_AbstractCrdt) {
  }
  _inheritsLoose(LiveMap, _AbstractCrdt);
  var _proto = LiveMap.prototype;
- return _proto._serialize = function(parentId, parentKey, doc, intent) {
+ return _proto._serialize = function(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");
   var ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
    type: exports.OpCode.CREATE_MAP,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey
   };
@@ -740,9 +975,7 @@ var LiveMap = function(_AbstractCrdt) {
   var children = parentToChildren.get(id);
   if (null == children) return map;
   for (var _step3, _iterator3 = _createForOfIteratorHelperLoose(children); !(_step3 = _iterator3()).done; ) {
-   var entry = _step3.value, 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");
-   var child = deserialize(entry, parentToChildren, doc);
+   var _step3$value = _step3.value, _id = _step3$value[0], crdt = _step3$value[1], child = deserialize([ _id, crdt ], parentToChildren, doc);
    child._setParentLink(map, crdt.parentKey), map._map.set(crdt.parentKey, child);
   }
   return map;
@@ -752,20 +985,24 @@ var LiveMap = function(_AbstractCrdt) {
    var _step4$value = _step4.value;
    _step4$value[0];
    var _value3 = _step4$value[1];
-   isCrdt(_value3) && _value3._attach(doc.generateId(), doc);
+   isLiveNode(_value3) && _value3._attach(doc.generateId(), doc);
   }
- }, _proto._attachChild = function(op, _isLocal) {
+ }, _proto._attachChild = function(op) {
   var _updates;
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, key = op.parentKey, child = creationOpToLiveStructure(op);
+  var id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
   if (void 0 !== this._doc.getItem(id)) return {
    modified: !1
   };
   var reverse, previousValue = this._map.get(key);
-  return previousValue ? (reverse = previousValue._serialize(this._id, key), previousValue._detach()) : reverse = [ {
+  if (previousValue) {
+   var thisId = nn(this._id);
+   reverse = previousValue._serialize(thisId, key), previousValue._detach();
+  } else reverse = [ {
    type: exports.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,
@@ -782,7 +1019,7 @@ var LiveMap = function(_AbstractCrdt) {
    _step5.value._detach();
   }
  }, _proto._detachChild = function(child) {
-  for (var _updates2, _step6, reverse = child._serialize(this._id, child._parentKey, this._doc), _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
+  for (var _updates2, _step6, id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc), _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
    var _step6$value = _step6.value, _key3 = _step6$value[0];
    _step6$value[1] === child && this._map.delete(_key3);
   }
@@ -790,26 +1027,26 @@ var LiveMap = function(_AbstractCrdt) {
    modified: {
     node: this,
     type: "LiveMap",
-    updates: (_updates2 = {}, _updates2[child._parentKey] = {
+    updates: (_updates2 = {}, _updates2[parentKey] = {
      type: "delete"
     }, _updates2)
    },
    reverse: reverse
   };
  }, _proto._toSerializedCrdt = function() {
-  var _this$_parent;
+  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveMap if parent is missing");
   return {
    type: exports.CrdtType.MAP,
-   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
-   parentKey: this._parentKey
+   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+   parentKey: this.parent.key
   };
  }, _proto.get = function(key) {
   var value = this._map.get(key);
-  if (null != value) return selfOrRegisterValue(value);
+  if (null != value) return liveNodeToLson(value);
  }, _proto.set = function(key, value) {
   var oldValue = this._map.get(key);
   oldValue && oldValue._detach();
-  var item = selfOrRegister(value);
+  var item = lsonToLiveNode(value);
   if (item._setParentLink(this, key), this._map.set(key, item), this._doc && this._id) {
    var _updates3, id = this._doc.generateId();
    item._attach(id, this._doc);
@@ -831,8 +1068,8 @@ var LiveMap = function(_AbstractCrdt) {
   var item = this._map.get(key);
   if (null == item) return !1;
   if (item._detach(), this._map.delete(key), this._doc && item._id) {
-   var _updates4, storageUpdates = new Map;
-   storageUpdates.set(this._id, {
+   var _updates4, thisId = nn(this._id), storageUpdates = new Map;
+   storageUpdates.set(thisId, {
     node: this,
     type: "LiveMap",
     updates: (_updates4 = {}, _updates4[key] = {
@@ -842,7 +1079,7 @@ var LiveMap = function(_AbstractCrdt) {
     type: exports.OpCode.DELETE_CRDT,
     id: item._id,
     opId: this._doc.generateOpId()
-   } ], item._serialize(this._id, key), storageUpdates);
+   } ], item._serialize(thisId, key), storageUpdates);
   }
   return !0;
  }, _proto.entries = function() {
@@ -855,7 +1092,7 @@ var LiveMap = function(_AbstractCrdt) {
     done: !0,
     value: void 0
    } : {
-    value: [ iteratorValue.value[0], selfOrRegisterValue(iteratorValue.value[1]) ]
+    value: [ iteratorValue.value[0], liveNodeToLson(iteratorValue.value[1]) ]
    };
   }, _ref2;
  }, _proto[_Symbol$iterator] = function() {
@@ -872,7 +1109,7 @@ var LiveMap = function(_AbstractCrdt) {
     done: !0,
     value: void 0
    } : {
-    value: selfOrRegisterValue(iteratorValue.value)
+    value: liveNodeToLson(iteratorValue.value)
    };
   }, _ref3;
  }, _proto.forEach = function(callback) {
@@ -888,7 +1125,15 @@ var LiveMap = function(_AbstractCrdt) {
  } ]), LiveMap;
 }(AbstractCrdt);
 
-function creationOpToLiveStructure(op) {
+function isJsonArray(data) {
+ return Array.isArray(data);
+}
+
+function isJsonObject(data) {
+ return null !== data && "object" == typeof data && !isJsonArray(data);
+}
+
+function creationOpToLiveNode(op) {
  switch (op.type) {
  case exports.OpCode.CREATE_REGISTER:
   return new LiveRegister(op.data);
@@ -901,6 +1146,9 @@ function creationOpToLiveStructure(op) {
 
  case exports.OpCode.CREATE_LIST:
   return new LiveList;
+
+ default:
+  return assertNever(0, "Unknown creation Op");
  }
 }
 
@@ -924,18 +1172,28 @@ function deserialize(_ref, 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 selfOrRegisterValue(obj) {
- return obj instanceof LiveRegister ? obj.data : obj;
+function isLiveObject(value) {
+ return value instanceof LiveObject;
 }
 
-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 liveNodeToLson(obj) {
+ return obj instanceof LiveRegister ? obj.data : obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject ? obj : assertNever(0, "Unknown AbstractCrdt");
+}
+
+function lsonToLiveNode(value) {
+ return value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList ? value : new LiveRegister(value);
 }
 
 function isPlain(value) {
@@ -968,19 +1226,18 @@ var LiveObject = function(_AbstractCrdt) {
   for (var key in void 0 === obj && (obj = {}), (_this = _AbstractCrdt.call(this) || this)._map = void 0, 
   _this._propToLastUpdate = void 0, _this._propToLastUpdate = new Map, obj) {
    var value = obj[key];
-   value instanceof AbstractCrdt && value._setParentLink(_assertThisInitialized(_this), key);
+   isLiveNode(value) && value._setParentLink(_assertThisInitialized(_this), key);
   }
   return _this._map = new Map(Object.entries(obj)), _this;
  }
  _inheritsLoose(LiveObject, _AbstractCrdt);
  var _proto = LiveObject.prototype;
- return _proto._serialize = function(parentId, parentKey, doc, intent) {
+ return _proto._serialize = function(parentId, parentKey, doc) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
   var opId = null == doc ? void 0 : doc.generateOpId(), ops = [], op = void 0 !== parentId && void 0 !== parentKey ? {
    type: exports.OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
-   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: {}
@@ -988,25 +1245,22 @@ var LiveObject = function(_AbstractCrdt) {
    type: exports.OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
-   intent: intent,
    data: {}
   };
   ops.push(op);
   for (var _step, _iterator = _createForOfIteratorHelperLoose(this._map); !(_step = _iterator()).done; ) {
    var _step$value = _step.value, key = _step$value[0], value = _step$value[1];
-   value instanceof AbstractCrdt ? ops.push.apply(ops, value._serialize(this._id, key, doc)) : op.data[key] = value;
+   isLiveNode(value) ? ops.push.apply(ops, value._serialize(this._id, key, doc)) : op.data[key] = value;
   }
   return ops;
  }, LiveObject._deserialize = function(_ref, parentToChildren, doc) {
   var id = _ref[0], liveObj = new LiveObject(_ref[1].data);
   return liveObj._attach(id, doc), this._deserializeChildren(liveObj, parentToChildren, doc);
  }, LiveObject._deserializeChildren = function(liveObj, parentToChildren, doc) {
-  var children = parentToChildren.get(liveObj._id);
+  var children = parentToChildren.get(nn(liveObj._id));
   if (null == children) return liveObj;
   for (var _step2, _iterator2 = _createForOfIteratorHelperLoose(children); !(_step2 = _iterator2()).done; ) {
-   var entry = _step2.value, 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");
-   var child = deserialize(entry, parentToChildren, doc);
+   var _step2$value = _step2.value, id = _step2$value[0], crdt = _step2$value[1], child = deserialize([ id, crdt ], parentToChildren, doc);
    child._setParentLink(liveObj, crdt.parentKey), liveObj._map.set(crdt.parentKey, child);
   }
   return liveObj;
@@ -1016,32 +1270,33 @@ var LiveObject = function(_AbstractCrdt) {
    var _step3$value = _step3.value;
    _step3$value[0];
    var value = _step3$value[1];
-   value instanceof AbstractCrdt && value._attach(doc.generateId(), doc);
+   isLiveNode(value) && value._attach(doc.generateId(), doc);
   }
- }, _proto._attachChild = function(op, isLocal) {
+ }, _proto._attachChild = function(op, source) {
   var _updates;
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, parentKey = op.parentKey, opId = op.opId, key = parentKey, child = creationOpToLiveStructure(op);
+  var id = op.id, opId = op.opId, key = op.parentKey, 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 === exports.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
   };
-  var reverse, previousValue = this._map.get(key);
-  if (isCrdt(previousValue)) reverse = previousValue._serialize(this._id, key), previousValue._detach(); else if (void 0 === previousValue) reverse = [ {
+  var reverse, thisId = nn(this._id), previousValue = this._map.get(key);
+  if (isLiveNode(previousValue)) reverse = previousValue._serialize(thisId, key), 
+  previousValue._detach(); else if (void 0 === previousValue) reverse = [ {
    type: exports.OpCode.DELETE_OBJECT_KEY,
-   id: this._id,
+   id: thisId,
    key: key
   } ]; else {
    var _data;
    reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
-    id: this._id,
+    id: thisId,
     data: (_data = {}, _data[key] = previousValue, _data)
    } ];
   }
@@ -1058,7 +1313,7 @@ var LiveObject = function(_AbstractCrdt) {
   };
  }, _proto._detachChild = function(child) {
   if (child) {
-   for (var _updates2, _step4, reverse = child._serialize(this._id, child._parentKey, this._doc), _iterator4 = _createForOfIteratorHelperLoose(this._map); !(_step4 = _iterator4()).done; ) {
+   for (var _updates2, _step4, id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc), _iterator4 = _createForOfIteratorHelperLoose(this._map); !(_step4 = _iterator4()).done; ) {
     var _step4$value = _step4.value, key = _step4$value[0];
     _step4$value[1] === child && this._map.delete(key);
    }
@@ -1066,7 +1321,7 @@ var LiveObject = function(_AbstractCrdt) {
     modified: {
      node: this,
      type: "LiveObject",
-     updates: (_updates2 = {}, _updates2[child._parentKey] = {
+     updates: (_updates2 = {}, _updates2[parentKey] = {
       type: "delete"
      }, _updates2)
     },
@@ -1076,51 +1331,46 @@ var LiveObject = function(_AbstractCrdt) {
   return {
    modified: !1
   };
- }, _proto._detachChildren = function() {
-  for (var _step5, _iterator5 = _createForOfIteratorHelperLoose(this._map); !(_step5 = _iterator5()).done; ) {
-   var _step5$value = _step5.value, key = _step5$value[0], value = _step5$value[1];
-   this._map.delete(key), value._detach();
-  }
  }, _proto._detach = function() {
   _AbstractCrdt.prototype._detach.call(this);
-  for (var _step6, _iterator6 = _createForOfIteratorHelperLoose(this._map.values()); !(_step6 = _iterator6()).done; ) {
-   var value = _step6.value;
-   isCrdt(value) && value._detach();
+  for (var _step5, _iterator5 = _createForOfIteratorHelperLoose(this._map.values()); !(_step5 = _iterator5()).done; ) {
+   var value = _step5.value;
+   isLiveNode(value) && value._detach();
   }
  }, _proto._apply = function(op, isLocal) {
   return op.type === exports.OpCode.UPDATE_OBJECT ? this._applyUpdate(op, isLocal) : op.type === exports.OpCode.DELETE_OBJECT_KEY ? this._applyDeleteObjectKey(op) : _AbstractCrdt.prototype._apply.call(this, op, isLocal);
  }, _proto._toSerializedCrdt = function() {
-  for (var _this$_parent, _step7, data = {}, _iterator7 = _createForOfIteratorHelperLoose(this._map); !(_step7 = _iterator7()).done; ) {
-   var _step7$value = _step7.value, key = _step7$value[0], value = _step7$value[1];
-   value instanceof AbstractCrdt == !1 && (data[key] = value);
+  for (var _step6, data = {}, _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
+   var _step6$value = _step6.value, key = _step6$value[0], value = _step6$value[1];
+   isLiveNode(value) || (data[key] = value);
   }
-  return void 0 !== (null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id) && void 0 !== this._parentKey ? {
+  return "HasParent" === this.parent.type && this.parent.node._id ? {
    type: exports.CrdtType.OBJECT,
-   parentId: this._parent._id,
-   parentKey: this._parentKey,
+   parentId: this.parent.node._id,
+   parentKey: this.parent.key,
    data: data
   } : {
    type: exports.CrdtType.OBJECT,
    data: data
   };
  }, _proto._applyUpdate = function(op, isLocal) {
-  var isModified = !1, reverse = [], reverseUpdate = {
+  var isModified = !1, id = nn(this._id), reverse = [], reverseUpdate = {
    type: exports.OpCode.UPDATE_OBJECT,
-   id: this._id,
+   id: id,
    data: {}
   };
   for (var key in reverse.push(reverseUpdate), op.data) {
    var oldValue = this._map.get(key);
-   oldValue instanceof AbstractCrdt ? (reverse.push.apply(reverse, oldValue._serialize(this._id, key)), 
+   isLiveNode(oldValue) ? (reverse.push.apply(reverse, oldValue._serialize(id, key)), 
    oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
     type: exports.OpCode.DELETE_OBJECT_KEY,
-    id: this._id,
+    id: id,
     key: key
    });
   }
   var updateDelta = {};
   for (var _key2 in op.data) {
-   if (isLocal) this._propToLastUpdate.set(_key2, op.opId); else {
+   if (isLocal) this._propToLastUpdate.set(_key2, nn(op.opId)); else {
     if (null != this._propToLastUpdate.get(_key2)) {
      if (this._propToLastUpdate.get(_key2) === op.opId) {
       this._propToLastUpdate.delete(_key2);
@@ -1131,7 +1381,7 @@ var LiveObject = function(_AbstractCrdt) {
     isModified = !0;
    }
    var _oldValue = this._map.get(_key2);
-   isCrdt(_oldValue) && _oldValue._detach(), isModified = !0, updateDelta[_key2] = {
+   isLiveNode(_oldValue) && _oldValue._detach(), isModified = !0, updateDelta[_key2] = {
     type: "update"
    }, this._map.set(_key2, op.data[_key2]);
   }
@@ -1154,12 +1404,12 @@ var LiveObject = function(_AbstractCrdt) {
   if (void 0 !== this._propToLastUpdate.get(key)) return {
    modified: !1
   };
-  var oldValue = this._map.get(key), reverse = [];
-  if (isCrdt(oldValue)) reverse = oldValue._serialize(this._id, op.key), oldValue._detach(); else if (void 0 !== oldValue) {
+  var oldValue = this._map.get(key), id = nn(this._id), reverse = [];
+  if (isLiveNode(oldValue)) reverse = oldValue._serialize(id, op.key), oldValue._detach(); else if (void 0 !== oldValue) {
    var _data2;
    reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
-    id: this._id,
+    id: id,
     data: (_data2 = {}, _data2[key] = oldValue, _data2)
    } ];
   }
@@ -1189,10 +1439,10 @@ var LiveObject = function(_AbstractCrdt) {
  }, _proto.delete = function(key) {
   var _updates4, keyAsString = key, oldValue = this._map.get(keyAsString);
   if (void 0 !== oldValue) {
-   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);
    var reverse, _data3;
-   if (oldValue instanceof AbstractCrdt) oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString); else reverse = [ {
+   if (isLiveNode(oldValue)) oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString); else reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
     data: (_data3 = {}, _data3[keyAsString] = oldValue, _data3),
     id: this._id
@@ -1222,19 +1472,19 @@ var LiveObject = function(_AbstractCrdt) {
    }, updateDelta = {};
    for (var _key3 in overrides) {
     var _oldValue2 = this._map.get(_key3);
-    _oldValue2 instanceof AbstractCrdt ? (reverseOps.push.apply(reverseOps, _oldValue2._serialize(this._id, _key3)), 
+    isLiveNode(_oldValue2) ? (reverseOps.push.apply(reverseOps, _oldValue2._serialize(this._id, _key3)), 
     _oldValue2._detach()) : void 0 === _oldValue2 ? reverseOps.push({
      type: exports.OpCode.DELETE_OBJECT_KEY,
      id: this._id,
      key: _key3
     }) : reverseUpdateOp.data[_key3] = _oldValue2;
     var _newValue = overrides[_key3];
-    if (_newValue instanceof AbstractCrdt) {
+    if (isLiveNode(_newValue)) {
      _newValue._setParentLink(this, _key3), _newValue._attach(this._doc.generateId(), this._doc);
      var newAttachChildOps = _newValue._serialize(this._id, _key3, this._doc), createCrdtOp = newAttachChildOps.find((function(op) {
       return op.parentId === _this2._id;
      }));
-     createCrdtOp && this._propToLastUpdate.set(_key3, createCrdtOp.opId), ops.push.apply(ops, newAttachChildOps);
+     createCrdtOp && this._propToLastUpdate.set(_key3, nn(createCrdtOp.opId)), ops.push.apply(ops, newAttachChildOps);
     } else updatedProps[_key3] = _newValue, this._propToLastUpdate.set(_key3, opId);
     this._map.set(_key3, _newValue), updateDelta[_key3] = {
      type: "update"
@@ -1255,23 +1505,22 @@ var LiveObject = function(_AbstractCrdt) {
    }), this._doc.dispatch(ops, reverseOps, storageUpdates);
   } else for (var key in overrides) {
    var oldValue = this._map.get(key);
-   oldValue instanceof AbstractCrdt && oldValue._detach();
+   isLiveNode(oldValue) && oldValue._detach();
    var 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);
   }
  }, LiveObject;
 }(AbstractCrdt);
 
-exports.AbstractCrdt = AbstractCrdt, exports.LiveList = LiveList, exports.LiveMap = LiveMap, 
-exports.LiveObject = LiveObject, exports.LiveRegister = LiveRegister, exports._createForOfIteratorHelperLoose = _createForOfIteratorHelperLoose, 
+exports.LiveList = LiveList, exports.LiveMap = LiveMap, exports.LiveObject = LiveObject, 
+exports.LiveRegister = LiveRegister, exports._createForOfIteratorHelperLoose = _createForOfIteratorHelperLoose, 
 exports._extends = _extends, exports._inheritsLoose = _inheritsLoose, exports._objectWithoutPropertiesLoose = function(source, excluded) {
  if (null == source) return {};
  var key, i, target = {}, sourceKeys = Object.keys(source);
  for (i = 0; i < sourceKeys.length; i++) key = sourceKeys[i], excluded.indexOf(key) >= 0 || (target[key] = source[key]);
  return target;
-}, exports._wrapNativeSuper = _wrapNativeSuper, exports.assertNever = function(_value, errmsg) {
- throw new Error(errmsg);
-}, exports.b64decode = function(b64value) {
+}, exports._wrapNativeSuper = _wrapNativeSuper, exports.assertNever = assertNever, 
+exports.b64decode = function(b64value) {
  try {
   var formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
   return decodeURIComponent(atob(formattedValue).split("").map((function(c) {
@@ -1284,10 +1533,9 @@ exports._extends = _extends, exports._inheritsLoose = _inheritsLoose, exports._o
  return items.filter((function(item) {
   return null != item;
  }));
-}, exports.comparePosition = comparePosition, exports.deprecate = deprecate, exports.deprecateIf = deprecateIf, 
-exports.errorIf = function(condition, message) {
- "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
-}, exports.findNonSerializableValue = function findNonSerializableValue(value, path) {
+}, exports.comparePosition = comparePosition, exports.deprecate = deprecate, exports.deprecateIf = function(condition, message, key) {
+ void 0 === key && (key = message), "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
+}, exports.errorIf = errorIf, exports.findNonSerializableValue = function findNonSerializableValue(value, path) {
  if (void 0 === path && (path = ""), !isPlain) return {
   path: path || "root",
   value: value
@@ -1321,7 +1569,7 @@ exports.errorIf = function(condition, message) {
   })), crdt.parentKey !== currentCrdt.parentKey && ops.push({
    type: exports.OpCode.SET_PARENT_KEY,
    id: id,
-   parentKey: crdt.parentKey
+   parentKey: nn(crdt.parentKey, "Parent key must not be missing")
   }); else switch (crdt.type) {
   case exports.CrdtType.REGISTER:
    ops.push({
@@ -1366,10 +1614,11 @@ exports.errorIf = function(condition, message) {
   }
  })), ops;
 }, exports.isChildCrdt = isChildCrdt, exports.isJsonArray = isJsonArray, exports.isJsonObject = isJsonObject, 
+exports.isLiveList = isLiveList, exports.isLiveNode = isLiveNode, exports.isLiveObject = isLiveObject, 
 exports.isRootCrdt = function(crdt) {
  return crdt.type === exports.CrdtType.OBJECT && !isChildCrdt(crdt);
 }, exports.isSameNodeOrChildOf = 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);
 }, exports.isTokenValid = function(token) {
  var tokenParts = token.split(".");
  if (3 !== tokenParts.length) return !1;
@@ -1397,7 +1646,7 @@ exports.isRootCrdt = function(crdt) {
    updates: first.updates.concat(second.updates)
   });
  }(first, second) : second : second;
-}, exports.remove = function(array, item) {
+}, exports.nn = nn, exports.remove = function(array, item) {
  for (var i = 0; i < array.length; i++) if (array[i] === item) {
   array.splice(i, 1);
   break;