@liveblocks/client 0.17.11-debug2 → 0.18.0-beta1

package/index.js

@@ -49,6 +49,20 @@ function _construct(Parent, args, Class) {
     }
     return _construct.apply(null, arguments);
 }
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
 function _defineProperty(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -163,33 +177,6 @@ function _objectSpreadProps(target, source) {
     }
     return target;
 }
-function _objectWithoutProperties(source, excluded) {
-    if (source == null) return {};
-    var target = _objectWithoutPropertiesLoose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
 function _possibleConstructorReturn(self, call) {
     if (call && (_typeof(call) === "object" || typeof call === "function")) {
         return call;
@@ -310,7 +297,304 @@ function _optionalChain(ops) {
     }
     return value;
 }
-var _chunkQLMVHHAZjs = require("./chunk-QLMVHHAZ.js");
+var _chunkZNCSOBAXjs = require("./chunk-ZNCSOBAX.js");
+// src/EventSource.ts
+function makeEventSource() {
+    var subscribe = function subscribe(callback) {
+        _observers.add(callback);
+        return function() {
+            return _observers.delete(callback);
+        };
+    };
+    var subscribeOnce = function subscribeOnce(callback) {
+        _onetimeObservers.add(callback);
+        return function() {
+            return _onetimeObservers.delete(callback);
+        };
+    };
+    var notify = function notify(event) {
+        _onetimeObservers.forEach(function(callback) {
+            return callback(event);
+        });
+        _onetimeObservers.clear();
+        _observers.forEach(function(callback) {
+            return callback(event);
+        });
+    };
+    var clear = function clear() {
+        _onetimeObservers.clear();
+        _observers.clear();
+    };
+    var _onetimeObservers = /* @__PURE__ */ new Set();
+    var _observers = /* @__PURE__ */ new Set();
+    return {
+        notify: notify,
+        subscribe: subscribe,
+        subscribeOnce: subscribeOnce,
+        clear: clear,
+        observable: {
+            subscribe: subscribe,
+            subscribeOnce: subscribeOnce
+        }
+    };
+}
+// src/ImmutableRef.ts
+function merge(target, patch) {
+    var updated = false;
+    var newValue = _objectSpread({}, target);
+    Object.keys(patch).forEach(function(k) {
+        var key = k;
+        var val = patch[key];
+        if (newValue[key] !== val) {
+            if (val === void 0) {
+                delete newValue[key];
+            } else {
+                newValue[key] = val;
+            }
+            updated = true;
+        }
+    });
+    return updated ? newValue : target;
+}
+var ImmutableRef = /*#__PURE__*/ function() {
+    function ImmutableRef() {
+        _classCallCheck(this, ImmutableRef);
+        this._ev = makeEventSource();
+    }
+    _createClass(ImmutableRef, [
+        {
+            key: "didInvalidate",
+            get: function get() {
+                return this._ev.observable;
+            }
+        },
+        {
+            key: "invalidate",
+            value: function invalidate() {
+                if (this._cache !== void 0) {
+                    this._cache = void 0;
+                    this._ev.notify();
+                }
+            }
+        },
+        {
+            key: "current",
+            get: function get() {
+                var _this = this;
+                return _nullishCoalesce(this._cache, function() {
+                    return _this._cache = _this._toImmutable();
+                });
+            }
+        }
+    ]);
+    return ImmutableRef;
+}();
+// src/MeRef.ts
+var MeRef = /*#__PURE__*/ function(ImmutableRef) {
+    _inherits(MeRef, ImmutableRef);
+    var _super = _createSuper(MeRef);
+    function MeRef(initialPresence) {
+        _classCallCheck(this, MeRef);
+        var _this;
+        _this = _super.call(this);
+        _this._me = _chunkZNCSOBAXjs.freeze.call(void 0, _chunkZNCSOBAXjs.compactObject.call(void 0, initialPresence));
+        return _this;
+    }
+    _createClass(MeRef, [
+        {
+            key: "_toImmutable",
+            value: function _toImmutable() {
+                return this._me;
+            }
+        },
+        {
+            key: "patch",
+            value: function patch(patch1) {
+                var oldMe = this._me;
+                var newMe = merge(oldMe, patch1);
+                if (oldMe !== newMe) {
+                    this._me = _chunkZNCSOBAXjs.freeze.call(void 0, newMe);
+                    this.invalidate();
+                }
+            }
+        }
+    ]);
+    return MeRef;
+}(ImmutableRef);
+// src/OthersRef.ts
+function makeUser(conn, presence) {
+    return _chunkZNCSOBAXjs.freeze.call(void 0, _chunkZNCSOBAXjs.compactObject.call(void 0, _objectSpreadProps(_objectSpread({}, conn), {
+        presence: presence
+    })));
+}
+var OthersRef = /*#__PURE__*/ function(ImmutableRef) {
+    _inherits(OthersRef, ImmutableRef);
+    var _super = _createSuper(OthersRef);
+    function OthersRef() {
+        _classCallCheck(this, OthersRef);
+        var _this;
+        _this = _super.call(this);
+        _this._connections = {};
+        _this._presences = {};
+        _this._users = {};
+        return _this;
+    }
+    _createClass(OthersRef, [
+        {
+            key: "_toImmutable",
+            value: function _toImmutable() {
+                var _this = this;
+                var users = _chunkZNCSOBAXjs.compact.call(void 0, Object.keys(this._presences).map(function(connectionId) {
+                    return _this.getUser(Number(connectionId));
+                }));
+                return _chunkZNCSOBAXjs.asArrayWithLegacyMethods.call(void 0, users);
+            }
+        },
+        {
+            key: "clearOthers",
+            value: function clearOthers() {
+                this._connections = {};
+                this._presences = {};
+                this._users = {};
+                this.invalidate();
+            }
+        },
+        {
+            key: "_getUser",
+            value: function _getUser(connectionId) {
+                var conn = this._connections[connectionId];
+                var presence = this._presences[connectionId];
+                if (conn !== void 0 && presence !== void 0) {
+                    return makeUser(conn, presence);
+                }
+                return void 0;
+            }
+        },
+        {
+            key: "getUser",
+            value: function getUser(connectionId) {
+                var cachedUser = this._users[connectionId];
+                if (cachedUser) {
+                    return cachedUser;
+                }
+                var computedUser = this._getUser(connectionId);
+                if (computedUser) {
+                    this._users[connectionId] = computedUser;
+                    return computedUser;
+                }
+                return void 0;
+            }
+        },
+        {
+            key: "_invalidateUser",
+            value: function _invalidateUser(connectionId) {
+                if (this._users[connectionId] !== void 0) {
+                    delete this._users[connectionId];
+                }
+                this.invalidate();
+            }
+        },
+        {
+            key: "setConnection",
+            value: function setConnection(connectionId, metaUserId, metaUserInfo) {
+                this._connections[connectionId] = _chunkZNCSOBAXjs.freeze.call(void 0, {
+                    connectionId: connectionId,
+                    id: metaUserId,
+                    info: metaUserInfo
+                });
+                if (this._presences[connectionId] !== void 0) {
+                    this._invalidateUser(connectionId);
+                }
+            }
+        },
+        {
+            key: "removeConnection",
+            value: function removeConnection(connectionId) {
+                delete this._connections[connectionId];
+                delete this._presences[connectionId];
+                this._invalidateUser(connectionId);
+            }
+        },
+        {
+            key: "setOther",
+            value: function setOther(connectionId, presence) {
+                this._presences[connectionId] = _chunkZNCSOBAXjs.freeze.call(void 0, _chunkZNCSOBAXjs.compactObject.call(void 0, presence));
+                if (this._connections[connectionId] !== void 0) {
+                    this._invalidateUser(connectionId);
+                }
+            }
+        },
+        {
+            key: "patchOther",
+            value: function patchOther(connectionId, patch) {
+                var oldPresence = this._presences[connectionId];
+                if (oldPresence === void 0) {
+                    return;
+                }
+                var newPresence = merge(oldPresence, patch);
+                if (oldPresence !== newPresence) {
+                    this._presences[connectionId] = _chunkZNCSOBAXjs.freeze.call(void 0, newPresence);
+                    this._invalidateUser(connectionId);
+                }
+            }
+        }
+    ]);
+    return OthersRef;
+}(ImmutableRef);
+// src/ValueRef.ts
+var ValueRef = /*#__PURE__*/ function(ImmutableRef) {
+    _inherits(ValueRef, ImmutableRef);
+    var _super = _createSuper(ValueRef);
+    function ValueRef(initialValue) {
+        _classCallCheck(this, ValueRef);
+        var _this;
+        _this = _super.call(this);
+        _this._value = _chunkZNCSOBAXjs.freeze.call(void 0, _chunkZNCSOBAXjs.compactObject.call(void 0, initialValue));
+        return _this;
+    }
+    _createClass(ValueRef, [
+        {
+            key: "_toImmutable",
+            value: function _toImmutable() {
+                return this._value;
+            }
+        },
+        {
+            key: "set",
+            value: function set(newValue) {
+                this._value = _chunkZNCSOBAXjs.freeze.call(void 0, newValue);
+                this.invalidate();
+            }
+        }
+    ]);
+    return ValueRef;
+}(ImmutableRef);
+var DerivedRef = /*#__PURE__*/ function(ImmutableRef) {
+    _inherits(DerivedRef, ImmutableRef);
+    var _super = _createSuper(DerivedRef);
+    function DerivedRef(otherRefs, transformFn) {
+        _classCallCheck(this, DerivedRef);
+        var _this;
+        _this = _super.call(this);
+        _this._refs = otherRefs;
+        _this._refs.forEach(function(ref) {
+            ref.didInvalidate.subscribe(function() {
+                return _this.invalidate();
+            });
+        });
+        _this._transform = transformFn;
+        return _this;
+    }
+    _createClass(DerivedRef, [
+        {
+            key: "_toImmutable",
+            value: function _toImmutable() {
+                return this._transform(this._refs[0].current, this._refs[1].current);
+            }
+        }
+    ]);
+    return DerivedRef;
+}(ImmutableRef);
 // src/room.ts
 var BACKOFF_RETRY_DELAYS = [
     250,
@@ -335,75 +619,16 @@ function makeIdFactory(connectionId) {
         return "".concat(connectionId, ":").concat(count++);
     };
 }
-function makeOthers(userMap) {
-    var users = Object.values(userMap).map(function(user) {
-        var _hasReceivedInitialPresence = user._hasReceivedInitialPresence, publicKeys = _objectWithoutProperties(user, [
-            "_hasReceivedInitialPresence"
-        ]);
-        return publicKeys;
-    });
-    var _obj;
-    return _obj = {
-        get count () {
-            return users.length;
-        }
-    }, _defineProperty(_obj, Symbol.iterator, function() {
-        return users[Symbol.iterator]();
-    }), _defineProperty(_obj, "map", function map(callback) {
-        return users.map(callback);
-    }), _defineProperty(_obj, "toArray", function toArray() {
-        return users;
-    }), _obj;
-}
 function log() {
     for(var _len = arguments.length, _params = new Array(_len), _key = 0; _key < _len; _key++){
         _params[_key] = arguments[_key];
     }
     return;
 }
-function makeStateMachine(state, context, mockedEffects) {
-    var genericSubscribe = function genericSubscribe(callback) {
-        state.listeners.storage.push(callback);
-        return function() {
-            return _chunkQLMVHHAZjs.remove.call(void 0, state.listeners.storage, callback);
-        };
-    };
-    var subscribeToLiveStructureDeeply = function subscribeToLiveStructureDeeply(node, callback) {
-        return genericSubscribe(function(updates) {
-            var relatedUpdates = updates.filter(function(update) {
-                return _chunkQLMVHHAZjs.isSameNodeOrChildOf.call(void 0, update.node, node);
-            });
-            if (relatedUpdates.length > 0) {
-                callback(relatedUpdates);
-            }
-        });
-    };
-    var subscribeToLiveStructureShallowly = function subscribeToLiveStructureShallowly(node, callback) {
-        return genericSubscribe(function(updates) {
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = updates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var update = _step.value;
-                    if (update.node._id === node._id) {
-                        callback(update.node);
-                    }
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-        });
-    };
+function isConnectionSelfAware(connection) {
+    return connection.state === "open" || connection.state === "connecting";
+}
+function makeStateMachine(state, config, mockedEffects) {
     var createOrUpdateRootFromMessage = function createOrUpdateRootFromMessage(message) {
         if (message.items.length === 0) {
             throw new Error("Internal error: cannot load storage without items");
@@ -426,7 +651,7 @@ function makeStateMachine(state, context, mockedEffects) {
         try {
             for(var _iterator = items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var _value = _slicedToArray(_step.value, 2), id = _value[0], crdt = _value[1];
-                if (_chunkQLMVHHAZjs.isRootCrdt.call(void 0, crdt)) {
+                if (_chunkZNCSOBAXjs.isRootCrdt.call(void 0, crdt)) {
                     root = [
                         id,
                         crdt
@@ -473,33 +698,16 @@ function makeStateMachine(state, context, mockedEffects) {
             return;
         }
         var currentItems = /* @__PURE__ */ new Map();
-        state.items.forEach(function(liveCrdt, id) {
-            currentItems.set(id, liveCrdt._toSerializedCrdt());
+        state.nodes.forEach(function(node, id) {
+            currentItems.set(id, node._serialize());
         });
-        var ops = _chunkQLMVHHAZjs.getTreesDiffOperations.call(void 0, currentItems, new Map(items));
+        var ops = _chunkZNCSOBAXjs.getTreesDiffOperations.call(void 0, currentItems, new Map(items));
         var result = apply(ops, false);
         notify(result.updates);
     };
     var load = function load(items) {
         var ref = _slicedToArray(buildRootAndParentToChildren(items), 2), root = ref[0], parentToChildren = ref[1];
-        return _chunkQLMVHHAZjs.LiveObject._deserialize(root, parentToChildren, {
-            getItem: getItem,
-            addItem: addItem,
-            deleteItem: deleteItem,
-            generateId: generateId,
-            generateOpId: generateOpId,
-            dispatch: storageDispatch,
-            roomId: context.roomId
-        });
-    };
-    var addItem = function addItem(id, liveItem) {
-        state.items.set(id, liveItem);
-    };
-    var deleteItem = function deleteItem(id) {
-        state.items.delete(id);
-    };
-    var getItem = function getItem(id) {
-        return state.items.get(id);
+        return _chunkZNCSOBAXjs.LiveObject._deserialize(root, parentToChildren, pool);
     };
     var addToUndoStack = function addToUndoStack(historyItem) {
         if (state.undoStack.length >= 50) {
@@ -513,51 +721,18 @@ function makeStateMachine(state, context, mockedEffects) {
             onHistoryChange();
         }
     };
-    var storageDispatch = function storageDispatch(ops, reverse, storageUpdates) {
-        if (state.isBatching) {
-            var _ops, _reverseOps;
-            (_ops = state.batch.ops).push.apply(_ops, _toConsumableArray(ops));
-            storageUpdates.forEach(function(value, key) {
-                state.batch.updates.storageUpdates.set(key, _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, state.batch.updates.storageUpdates.get(key), value));
-            });
-            (_reverseOps = state.batch.reverseOps).push.apply(_reverseOps, _toConsumableArray(reverse));
-        } else {
-            addToUndoStack(reverse);
-            state.redoStack = [];
-            dispatch(ops);
-            notify({
-                storageUpdates: storageUpdates
-            });
-        }
-    };
     var notify = function notify(param) {
         var _storageUpdates = param.storageUpdates, storageUpdates = _storageUpdates === void 0 ? /* @__PURE__ */ new Map() : _storageUpdates, _presence = param.presence, presence = _presence === void 0 ? false : _presence, tmp = param.others, otherEvents = tmp === void 0 ? [] : tmp;
         if (otherEvents.length > 0) {
-            state.others = makeOthers(state.users);
+            var others = state.others.current;
             var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
                 for(var _iterator = otherEvents[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                     var event = _step.value;
-                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                    try {
-                        for(var _iterator1 = state.listeners.others[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var listener = _step1.value;
-                            listener(state.others, event);
-                        }
-                    } catch (err) {
-                        _didIteratorError1 = true;
-                        _iteratorError1 = err;
-                    } finally{
-                        try {
-                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                _iterator1.return();
-                            }
-                        } finally{
-                            if (_didIteratorError1) {
-                                throw _iteratorError1;
-                            }
-                        }
-                    }
+                    eventHub.others.notify({
+                        others: others,
+                        event: event
+                    });
                 }
             } catch (err) {
                 _didIteratorError = true;
@@ -575,64 +750,22 @@ function makeStateMachine(state, context, mockedEffects) {
             }
         }
         if (presence) {
-            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
-            try {
-                for(var _iterator2 = state.listeners["my-presence"][Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                    var listener1 = _step2.value;
-                    listener1(state.me);
-                }
-            } catch (err) {
-                _didIteratorError2 = true;
-                _iteratorError2 = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                        _iterator2.return();
-                    }
-                } finally{
-                    if (_didIteratorError2) {
-                        throw _iteratorError2;
-                    }
-                }
-            }
+            eventHub.me.notify(state.me.current);
         }
         if (storageUpdates.size > 0) {
-            var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
-            try {
-                for(var _iterator3 = state.listeners.storage[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
-                    var subscriber = _step3.value;
-                    subscriber(Array.from(storageUpdates.values()));
-                }
-            } catch (err) {
-                _didIteratorError3 = true;
-                _iteratorError3 = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                        _iterator3.return();
-                    }
-                } finally{
-                    if (_didIteratorError3) {
-                        throw _iteratorError3;
-                    }
-                }
-            }
+            var updates = Array.from(storageUpdates.values());
+            eventHub.storage.notify(updates);
         }
     };
     var getConnectionId = function getConnectionId() {
-        if (state.connection.state === "open" || state.connection.state === "connecting") {
-            return state.connection.id;
+        var conn = state.connection.current;
+        if (isConnectionSelfAware(conn)) {
+            return conn.id;
         } else if (state.lastConnectionId !== null) {
             return state.lastConnectionId;
         }
         throw new Error("Internal. Tried to get connection id but connection was never open");
     };
-    var generateId = function generateId() {
-        return "".concat(getConnectionId(), ":").concat(state.clock++);
-    };
-    var generateOpId = function generateOpId() {
-        return "".concat(getConnectionId(), ":").concat(state.opClock++);
-    };
     var apply = function apply(item, isLocal) {
         var result = {
             reverse: [],
@@ -652,17 +785,17 @@ function makeStateMachine(state, context, mockedEffects) {
                         data: {}
                     };
                     for(var key in op.data){
-                        reverse.data[key] = state.me[key];
+                        reverse.data[key] = state.me.current[key];
                     }
-                    state.me = _objectSpread({}, state.me, op.data);
-                    if (state.buffer.presence == null) {
-                        state.buffer.presence = {
+                    state.me.patch(op.data);
+                    if (state.buffer.me == null) {
+                        state.buffer.me = {
                             type: "partial",
                             data: op.data
                         };
                     } else {
                         for(var key1 in op.data){
-                            state.buffer.presence.data[key1] = op.data[key1];
+                            state.buffer.me.data[key1] = op.data[key1];
                         }
                     }
                     result.reverse.unshift(reverse);
@@ -670,24 +803,24 @@ function makeStateMachine(state, context, mockedEffects) {
                 } else {
                     var source = void 0;
                     if (!op.opId) {
-                        op.opId = generateOpId();
+                        op.opId = pool.generateOpId();
                     }
                     if (isLocal) {
                         source = 0 /* UNDOREDO_RECONNECT */ ;
                     } else {
-                        var deleted = state.offlineOperations.delete(_chunkQLMVHHAZjs.nn.call(void 0, op.opId));
+                        var deleted = state.offlineOperations.delete(_chunkZNCSOBAXjs.nn.call(void 0, op.opId));
                         source = deleted ? 2 /* ACK */  : 1 /* REMOTE */ ;
                     }
                     var applyOpResult = applyOp(op, source);
                     if (applyOpResult.modified) {
-                        var parentId = applyOpResult.modified.node.parent.type === "HasParent" ? _chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node.parent.node._id, "Expected parent node to have an ID") : void 0;
+                        var parentId = applyOpResult.modified.node.parent.type === "HasParent" ? _chunkZNCSOBAXjs.nn.call(void 0, applyOpResult.modified.node.parent.node._id, "Expected parent node to have an ID") : void 0;
                         if (!parentId || !createdNodeIds.has(parentId)) {
                             var _reverse;
-                            result.updates.storageUpdates.set(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id), _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, result.updates.storageUpdates.get(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id)), applyOpResult.modified));
+                            result.updates.storageUpdates.set(_chunkZNCSOBAXjs.nn.call(void 0, applyOpResult.modified.node._id), _chunkZNCSOBAXjs.mergeStorageUpdates.call(void 0, result.updates.storageUpdates.get(_chunkZNCSOBAXjs.nn.call(void 0, applyOpResult.modified.node._id)), applyOpResult.modified));
                             (_reverse = result.reverse).unshift.apply(_reverse, _toConsumableArray(applyOpResult.reverse));
                         }
                         if (op.type === 2 /* CREATE_LIST */  || op.type === 7 /* CREATE_MAP */  || op.type === 4 /* CREATE_OBJECT */ ) {
-                            createdNodeIds.add(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id));
+                            createdNodeIds.add(_chunkZNCSOBAXjs.nn.call(void 0, applyOpResult.modified.node._id));
                         }
                     }
                 }
@@ -714,24 +847,24 @@ function makeStateMachine(state, context, mockedEffects) {
             case 3 /* UPDATE_OBJECT */ :
             case 5 /* DELETE_CRDT */ :
                 {
-                    var item = state.items.get(op.id);
-                    if (item == null) {
+                    var node = state.nodes.get(op.id);
+                    if (node == null) {
                         return {
                             modified: false
                         };
                     }
-                    return item._apply(op, source === 0 /* UNDOREDO_RECONNECT */ );
+                    return node._apply(op, source === 0 /* UNDOREDO_RECONNECT */ );
                 }
             case 1 /* SET_PARENT_KEY */ :
                 {
-                    var item1 = state.items.get(op.id);
-                    if (item1 == null) {
+                    var node1 = state.nodes.get(op.id);
+                    if (node1 == null) {
                         return {
                             modified: false
                         };
                     }
-                    if (item1.parent.type === "HasParent" && _chunkQLMVHHAZjs.isLiveList.call(void 0, item1.parent.node)) {
-                        return item1.parent.node._setChildKey(op.parentKey, item1, source);
+                    if (node1.parent.type === "HasParent" && _chunkZNCSOBAXjs.isLiveList.call(void 0, node1.parent.node)) {
+                        return node1.parent.node._setChildKey(op.parentKey, node1, source);
                     }
                     return {
                         modified: false
@@ -747,26 +880,92 @@ function makeStateMachine(state, context, mockedEffects) {
                             modified: false
                         };
                     }
-                    var parent = state.items.get(op.parentId);
-                    if (parent == null) {
+                    var parentNode = state.nodes.get(op.parentId);
+                    if (parentNode == null) {
                         return {
                             modified: false
                         };
                     }
-                    return parent._attachChild(op, source);
+                    return parentNode._attachChild(op, source);
                 }
         }
     };
+    var subscribeToLiveStructureDeeply = function subscribeToLiveStructureDeeply(node, callback) {
+        return eventHub.storage.subscribe(function(updates) {
+            var relatedUpdates = updates.filter(function(update) {
+                return _chunkZNCSOBAXjs.isSameNodeOrChildOf.call(void 0, update.node, node);
+            });
+            if (relatedUpdates.length > 0) {
+                callback(relatedUpdates);
+            }
+        });
+    };
+    var subscribeToLiveStructureShallowly = function subscribeToLiveStructureShallowly(node, callback) {
+        return eventHub.storage.subscribe(function(updates) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = updates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var update = _step.value;
+                    if (update.node._id === node._id) {
+                        callback(update.node);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        });
+    };
     var subscribe = function subscribe(first, second, options) {
+        if (typeof first === "string" && _chunkZNCSOBAXjs.isRoomEventName.call(void 0, first)) {
+            if (typeof second !== "function") {
+                throw new Error("Second argument must be a callback function");
+            }
+            var callback = second;
+            switch(first){
+                case "event":
+                    return eventHub.customEvent.subscribe(callback);
+                case "my-presence":
+                    return eventHub.me.subscribe(callback);
+                case "others":
+                    {
+                        var cb = callback;
+                        return eventHub.others.subscribe(function(param) {
+                            var others = param.others, event = param.event;
+                            return cb(others, event);
+                        });
+                    }
+                case "error":
+                    return eventHub.error.subscribe(callback);
+                case "connection":
+                    return eventHub.connection.subscribe(callback);
+                case "storage":
+                    return eventHub.storage.subscribe(callback);
+                case "history":
+                    return eventHub.history.subscribe(callback);
+                default:
+                    return _chunkZNCSOBAXjs.assertNever.call(void 0, first, "Unknown event");
+            }
+        }
         if (second === void 0 || typeof first === "function") {
             if (typeof first === "function") {
                 var storageCallback = first;
-                return genericSubscribe(storageCallback);
+                return eventHub.storage.subscribe(storageCallback);
             } else {
                 throw new Error("Please specify a listener callback");
             }
         }
-        if (_chunkQLMVHHAZjs.isLiveNode.call(void 0, first)) {
+        if (_chunkZNCSOBAXjs.isLiveNode.call(void 0, first)) {
             var node = first;
             if (_optionalChain([
                 options,
@@ -782,34 +981,17 @@ function makeStateMachine(state, context, mockedEffects) {
                 return subscribeToLiveStructureShallowly(node, nodeCallback);
             }
         }
-        if (!_chunkQLMVHHAZjs.isRoomEventName.call(void 0, first)) {
-            throw new Error('"'.concat(first, '" is not a valid event name'));
-        }
-        var eventName = first;
-        var eventListener = second;
-        state.listeners[eventName].push(eventListener);
-        return function() {
-            var callbacks = state.listeners[eventName];
-            _chunkQLMVHHAZjs.remove.call(void 0, callbacks, eventListener);
-        };
+        throw new Error('"'.concat(first, '" is not a valid event name'));
     };
     var getConnectionState = function getConnectionState() {
-        return state.connection.state;
-    };
-    var getSelf = function getSelf() {
-        return state.connection.state === "open" || state.connection.state === "connecting" ? {
-            connectionId: state.connection.id,
-            id: state.connection.userId,
-            info: state.connection.userInfo,
-            presence: getPresence()
-        } : null;
+        return state.connection.current.state;
     };
     var connect = function connect() {
-        if (state.connection.state !== "closed" && state.connection.state !== "unavailable") {
+        if (state.connection.current.state !== "closed" && state.connection.current.state !== "unavailable") {
             return null;
         }
-        var auth = prepareAuthEndpoint(context.authentication, _nullishCoalesce(_optionalChain([
-            context,
+        var auth = prepareAuthEndpoint(config.authentication, _nullishCoalesce(_optionalChain([
+            config,
             "access",
             function(_2) {
                 return _2.polyfills;
@@ -819,10 +1001,10 @@ function makeStateMachine(state, context, mockedEffects) {
                 return _3.fetch;
             }
         ]), function() {
-            return context.fetchPolyfill;
+            return config.fetchPolyfill;
         }));
-        var createWebSocket = prepareCreateWebSocket(context.liveblocksServer, _nullishCoalesce(_optionalChain([
-            context,
+        var createWebSocket = prepareCreateWebSocket(config.liveblocksServer, _nullishCoalesce(_optionalChain([
+            config,
             "access",
             function(_4) {
                 return _4.polyfills;
@@ -832,30 +1014,30 @@ function makeStateMachine(state, context, mockedEffects) {
                 return _5.WebSocket;
             }
         ]), function() {
-            return context.WebSocketPolyfill;
+            return config.WebSocketPolyfill;
         }));
         updateConnection({
             state: "authenticating"
         });
         effects.authenticate(auth, createWebSocket);
     };
-    var updatePresence = function updatePresence(overrides, options) {
+    var updatePresence = function updatePresence(patch, options) {
         var oldValues = {};
-        if (state.buffer.presence == null) {
-            state.buffer.presence = {
+        if (state.buffer.me == null) {
+            state.buffer.me = {
                 type: "partial",
                 data: {}
             };
         }
-        for(var key in overrides){
-            var overrideValue = overrides[key];
+        for(var key in patch){
+            var overrideValue = patch[key];
             if (overrideValue === void 0) {
                 continue;
             }
-            state.buffer.presence.data[key] = overrideValue;
-            oldValues[key] = state.me[key];
+            state.buffer.me.data[key] = overrideValue;
+            oldValues[key] = state.me.current[key];
         }
-        state.me = _objectSpread({}, state.me, overrides);
+        state.me.patch(patch);
         if (state.isBatching) {
             if (_optionalChain([
                 options,
@@ -917,44 +1099,40 @@ function makeStateMachine(state, context, mockedEffects) {
         state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
     };
     var onVisibilityChange = function onVisibilityChange(visibilityState) {
-        if (visibilityState === "visible" && state.connection.state === "open") {
+        if (visibilityState === "visible" && state.connection.current.state === "open") {
             log("Heartbeat after visibility change");
             heartbeat();
         }
     };
     var onUpdatePresenceMessage = function onUpdatePresenceMessage(message) {
-        var user = state.users[message.actor];
-        if (message.targetActor === void 0 && user != null && !user._hasReceivedInitialPresence) {
-            return void 0;
+        if (message.targetActor !== void 0) {
+            var oldUser = state.others.getUser(message.actor);
+            state.others.setOther(message.actor, message.data);
+            var newUser = state.others.getUser(message.actor);
+            if (oldUser === void 0 && newUser !== void 0) {
+                return {
+                    type: "enter",
+                    user: newUser
+                };
+            }
+        } else {
+            state.others.patchOther(message.actor, message.data), message;
         }
-        if (user == null) {
-            state.users[message.actor] = {
-                connectionId: message.actor,
-                presence: message.data,
-                id: void 0,
-                info: void 0,
-                _hasReceivedInitialPresence: true
+        var user = state.others.getUser(message.actor);
+        if (user) {
+            return {
+                type: "update",
+                updates: message.data,
+                user: user
             };
         } else {
-            state.users[message.actor] = {
-                id: user.id,
-                info: user.info,
-                connectionId: message.actor,
-                presence: _objectSpread({}, user.presence, message.data),
-                _hasReceivedInitialPresence: true
-            };
+            return void 0;
         }
-        return {
-            type: "update",
-            updates: message.data,
-            user: state.users[message.actor]
-        };
     };
     var onUserLeftMessage = function onUserLeftMessage(message) {
-        var userLeftMessage = message;
-        var user = state.users[userLeftMessage.actor];
+        var user = state.others.getUser(message.actor);
         if (user) {
-            delete state.users[userLeftMessage.actor];
+            state.others.removeConnection(message.actor);
             return {
                 type: "leave",
                 user: user
@@ -963,113 +1141,57 @@ function makeStateMachine(state, context, mockedEffects) {
         return null;
     };
     var onRoomStateMessage = function onRoomStateMessage(message) {
-        var newUsers = {};
         for(var key in message.users){
-            var connectionId = Number.parseInt(key);
             var user = message.users[key];
-            newUsers[connectionId] = {
-                connectionId: connectionId,
-                info: user.info,
-                id: user.id
-            };
+            var connectionId = Number(key);
+            state.others.setConnection(connectionId, user.id, user.info);
         }
-        state.users = newUsers;
         return {
             type: "reset"
         };
     };
     var onNavigatorOnline = function onNavigatorOnline() {
-        if (state.connection.state === "unavailable") {
+        if (state.connection.current.state === "unavailable") {
             log("Try to reconnect after connectivity change");
             reconnect();
         }
     };
-    var onEvent = function onEvent(message) {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.event[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener({
-                    connectionId: message.actor,
-                    event: message.event
-                });
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    };
     var onHistoryChange = function onHistoryChange() {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.history[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener({
-                    canUndo: canUndo(),
-                    canRedo: canRedo()
-                });
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
+        eventHub.history.notify({
+            canUndo: canUndo(),
+            canRedo: canRedo()
+        });
     };
     var onUserJoinedMessage = function onUserJoinedMessage(message) {
-        state.users[message.actor] = {
-            connectionId: message.actor,
-            info: message.info,
-            id: message.id,
-            _hasReceivedInitialPresence: true
-        };
-        if (state.me) {
-            state.buffer.messages.push({
-                type: 100 /* UPDATE_PRESENCE */ ,
-                data: state.me,
-                targetActor: message.actor
-            });
-            tryFlushing();
-        }
-        return {
+        state.others.setConnection(message.actor, message.id, message.info);
+        state.buffer.messages.push({
+            type: 100 /* UPDATE_PRESENCE */ ,
+            data: state.me.current,
+            targetActor: message.actor
+        });
+        tryFlushing();
+        var user = state.others.getUser(message.actor);
+        return user ? {
             type: "enter",
-            user: state.users[message.actor]
-        };
+            user: user
+        } : void 0;
     };
     var parseServerMessage = function parseServerMessage(data) {
-        if (!_chunkQLMVHHAZjs.isJsonObject.call(void 0, data)) {
+        if (!_chunkZNCSOBAXjs.isJsonObject.call(void 0, data)) {
             return null;
         }
         return data;
     };
     var parseServerMessages = function parseServerMessages(text) {
-        var data = _chunkQLMVHHAZjs.tryParseJson.call(void 0, text);
+        var data = _chunkZNCSOBAXjs.tryParseJson.call(void 0, text);
         if (data === void 0) {
             return null;
-        } else if (_chunkQLMVHHAZjs.isJsonArray.call(void 0, data)) {
-            return _chunkQLMVHHAZjs.compact.call(void 0, data.map(function(item) {
+        } else if (_chunkZNCSOBAXjs.isJsonArray.call(void 0, data)) {
+            return _chunkZNCSOBAXjs.compact.call(void 0, data.map(function(item) {
                 return parseServerMessage(item);
             }));
         } else {
-            return _chunkQLMVHHAZjs.compact.call(void 0, [
+            return _chunkZNCSOBAXjs.compact.call(void 0, [
                 parseServerMessage(data)
             ]);
         }
@@ -1094,7 +1216,10 @@ function makeStateMachine(state, context, mockedEffects) {
                 switch(message.type){
                     case 101 /* USER_JOINED */ :
                         {
-                            updates.others.push(onUserJoinedMessage(message));
+                            var userJoinedUpdate = onUserJoinedMessage(message);
+                            if (userJoinedUpdate) {
+                                updates.others.push(userJoinedUpdate);
+                            }
                             break;
                         }
                     case 100 /* UPDATE_PRESENCE */ :
@@ -1107,7 +1232,10 @@ function makeStateMachine(state, context, mockedEffects) {
                         }
                     case 103 /* BROADCASTED_EVENT */ :
                         {
-                            onEvent(message);
+                            eventHub.customEvent.notify({
+                                connectionId: message.actor,
+                                event: message.event
+                            });
                             break;
                         }
                     case 102 /* USER_LEFT */ :
@@ -1135,13 +1263,14 @@ function makeStateMachine(state, context, mockedEffects) {
                                     return _8();
                                 }
                             ]);
+                            eventHub.storageDidLoad.notify();
                             break;
                         }
                     case 201 /* UPDATE_STORAGE */ :
                         {
                             var applyResult = apply(message.ops, false);
                             applyResult.updates.storageUpdates.forEach(function(value, key) {
-                                updates.storageUpdates.set(key, _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, updates.storageUpdates.get(key), value));
+                                updates.storageUpdates.set(key, _chunkZNCSOBAXjs.mergeStorageUpdates.call(void 0, updates.storageUpdates.get(key), value));
                             });
                             break;
                         }
@@ -1171,7 +1300,7 @@ function makeStateMachine(state, context, mockedEffects) {
             clearTimeout(state.timeoutHandles.flush);
         }
         clearTimeout(state.timeoutHandles.reconnect);
-        state.users = {};
+        state.others.clearOthers();
         notify({
             others: [
                 {
@@ -1184,26 +1313,7 @@ function makeStateMachine(state, context, mockedEffects) {
                 state: "failed"
             });
             var error = new LiveblocksError(event.reason, event.code);
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = state.listeners.error[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var listener = _step.value;
-                    listener(error);
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
+            eventHub.error.notify(error);
             var delay = getRetryDelay(true);
             state.numberOfRetry++;
             if (process.env.NODE_ENV !== "production") {
@@ -1230,27 +1340,8 @@ function makeStateMachine(state, context, mockedEffects) {
         }
     };
     var updateConnection = function updateConnection(connection) {
-        state.connection = connection;
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.connection[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener(connection.state);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
+        state.connection.set(connection);
+        eventHub.connection.notify(connection.state);
     };
     var getRetryDelay = function getRetryDelay() {
         var slow = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
@@ -1263,19 +1354,19 @@ function makeStateMachine(state, context, mockedEffects) {
     var onOpen = function onOpen() {
         clearInterval(state.intervalHandles.heartbeat);
         state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
-        if (state.connection.state === "connecting") {
-            updateConnection(_objectSpreadProps(_objectSpread({}, state.connection), {
+        if (state.connection.current.state === "connecting") {
+            updateConnection(_objectSpreadProps(_objectSpread({}, state.connection.current), {
                 state: "open"
             }));
             state.numberOfRetry = 0;
             if (state.lastConnectionId !== void 0) {
-                state.buffer.presence = {
+                state.buffer.me = {
                     type: "full",
-                    data: state.me
+                    data: state.me.current
                 };
                 tryFlushing();
             }
-            state.lastConnectionId = state.connection.id;
+            state.lastConnectionId = state.connection.current.id;
             if (state.root) {
                 state.buffer.messages.push({
                     type: 200 /* FETCH_STORAGE */ 
@@ -1336,7 +1427,7 @@ function makeStateMachine(state, context, mockedEffects) {
         var storageOps = state.buffer.storageOperations;
         if (storageOps.length > 0) {
             storageOps.forEach(function(op) {
-                state.offlineOperations.set(_chunkQLMVHHAZjs.nn.call(void 0, op.opId), op);
+                state.offlineOperations.set(_chunkZNCSOBAXjs.nn.call(void 0, op.opId), op);
             });
         }
         if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
@@ -1345,7 +1436,7 @@ function makeStateMachine(state, context, mockedEffects) {
         }
         var now = Date.now();
         var elapsedTime = now - state.lastFlushTime;
-        if (elapsedTime > context.throttleDelay) {
+        if (elapsedTime > config.throttleDelay) {
             var messages = flushDataToMessages(state);
             if (messages.length === 0) {
                 return;
@@ -1354,26 +1445,26 @@ function makeStateMachine(state, context, mockedEffects) {
             state.buffer = {
                 messages: [],
                 storageOperations: [],
-                presence: null
+                me: null
             };
             state.lastFlushTime = now;
         } else {
             if (state.timeoutHandles.flush != null) {
                 clearTimeout(state.timeoutHandles.flush);
             }
-            state.timeoutHandles.flush = effects.delayFlush(context.throttleDelay - (now - state.lastFlushTime));
+            state.timeoutHandles.flush = effects.delayFlush(config.throttleDelay - (now - state.lastFlushTime));
         }
     };
     var flushDataToMessages = function flushDataToMessages(state2) {
         var messages = [];
-        if (state2.buffer.presence) {
-            messages.push(state2.buffer.presence.type === "full" ? {
+        if (state2.buffer.me) {
+            messages.push(state2.buffer.me.type === "full" ? {
                 type: 100 /* UPDATE_PRESENCE */ ,
                 targetActor: -1,
-                data: state2.buffer.presence.data
+                data: state2.buffer.me.data
             } : {
                 type: 100 /* UPDATE_PRESENCE */ ,
-                data: state2.buffer.presence.data
+                data: state2.buffer.me.data
             });
         }
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
@@ -1422,7 +1513,7 @@ function makeStateMachine(state, context, mockedEffects) {
         clearTimeout(state.timeoutHandles.reconnect);
         clearTimeout(state.timeoutHandles.pongTimeout);
         clearInterval(state.intervalHandles.heartbeat);
-        state.users = {};
+        state.others.clearOthers();
         notify({
             others: [
                 {
@@ -1430,18 +1521,15 @@ function makeStateMachine(state, context, mockedEffects) {
                 }
             ]
         });
-        clearListeners();
-    };
-    var clearListeners = function clearListeners() {
-        for(var key in state.listeners){
-            state.listeners[key] = [];
-        }
+        Object.values(eventHub).forEach(function(eventSource) {
+            return eventSource.clear();
+        });
     };
     var getPresence = function getPresence() {
-        return state.me;
+        return state.me.current;
     };
     var getOthers = function getOthers() {
-        return state.others;
+        return state.others.current;
     };
     var broadcastEvent = function broadcastEvent(event) {
         var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
@@ -1456,19 +1544,12 @@ function makeStateMachine(state, context, mockedEffects) {
         });
         tryFlushing();
     };
-    var dispatch = function dispatch(ops) {
+    var dispatchOps = function dispatchOps(ops) {
         var _storageOperations;
         (_storageOperations = state.buffer.storageOperations).push.apply(_storageOperations, _toConsumableArray(ops));
         tryFlushing();
     };
-    var getStorage = function getStorage() {
-        if (state.root) {
-            return new Promise(function(resolve) {
-                return resolve({
-                    root: state.root
-                });
-            });
-        }
+    var startLoadingStorage = function startLoadingStorage() {
         if (_getInitialStatePromise == null) {
             state.buffer.messages.push({
                 type: 200 /* FETCH_STORAGE */ 
@@ -1478,9 +1559,26 @@ function makeStateMachine(state, context, mockedEffects) {
                 return _getInitialStateResolver = resolve;
             });
         }
-        return _getInitialStatePromise.then(function() {
+        return _getInitialStatePromise;
+    };
+    var getStorageSnapshot = function getStorageSnapshot() {
+        var root = state.root;
+        if (root !== void 0) {
+            return root;
+        } else {
+            startLoadingStorage();
+            return null;
+        }
+    };
+    var getStorage = function getStorage() {
+        if (state.root) {
+            return Promise.resolve({
+                root: state.root
+            });
+        }
+        return startLoadingStorage().then(function() {
             return {
-                root: _chunkQLMVHHAZjs.nn.call(void 0, state.root)
+                root: _chunkZNCSOBAXjs.nn.call(void 0, state.root)
             };
         });
     };
@@ -1580,7 +1678,7 @@ function makeStateMachine(state, context, mockedEffects) {
                 state.redoStack = [];
             }
             if (state.batch.ops.length > 0) {
-                dispatch(state.batch.ops);
+                dispatchOps(state.batch.ops);
             }
             notify(state.batch.updates);
             state.batch = {
@@ -1614,20 +1712,65 @@ function makeStateMachine(state, context, mockedEffects) {
     var simulateSendCloseEvent = function simulateSendCloseEvent(event) {
         onClose(event);
     };
+    var pool = {
+        roomId: config.roomId,
+        getNode: function(id) {
+            return state.nodes.get(id);
+        },
+        addNode: function(id, node) {
+            return void state.nodes.set(id, node);
+        },
+        deleteNode: function(id) {
+            return void state.nodes.delete(id);
+        },
+        generateId: function() {
+            return "".concat(getConnectionId(), ":").concat(state.clock++);
+        },
+        generateOpId: function() {
+            return "".concat(getConnectionId(), ":").concat(state.opClock++);
+        },
+        dispatch: function dispatch(ops, reverse, storageUpdates) {
+            if (state.isBatching) {
+                var _ops, _reverseOps;
+                (_ops = state.batch.ops).push.apply(_ops, _toConsumableArray(ops));
+                storageUpdates.forEach(function(value, key) {
+                    state.batch.updates.storageUpdates.set(key, _chunkZNCSOBAXjs.mergeStorageUpdates.call(void 0, state.batch.updates.storageUpdates.get(key), value));
+                });
+                (_reverseOps = state.batch.reverseOps).push.apply(_reverseOps, _toConsumableArray(reverse));
+            } else {
+                addToUndoStack(reverse);
+                state.redoStack = [];
+                dispatchOps(ops);
+                notify({
+                    storageUpdates: storageUpdates
+                });
+            }
+        }
+    };
+    var eventHub = {
+        customEvent: makeEventSource(),
+        me: makeEventSource(),
+        others: makeEventSource(),
+        error: makeEventSource(),
+        connection: makeEventSource(),
+        storage: makeEventSource(),
+        history: makeEventSource(),
+        storageDidLoad: makeEventSource()
+    };
     var effects = mockedEffects || {
         authenticate: function authenticate(auth, createWebSocket) {
             var rawToken = state.token;
-            var parsedToken = rawToken !== null && _chunkQLMVHHAZjs.parseRoomAuthToken.call(void 0, rawToken);
-            if (parsedToken && !_chunkQLMVHHAZjs.isTokenExpired.call(void 0, parsedToken)) {
+            var parsedToken = rawToken !== null && _chunkZNCSOBAXjs.parseRoomAuthToken.call(void 0, rawToken);
+            if (parsedToken && !_chunkZNCSOBAXjs.isTokenExpired.call(void 0, parsedToken)) {
                 var socket = createWebSocket(rawToken);
                 authenticationSuccess(parsedToken, socket);
             } else {
-                return auth(context.roomId).then(function(param) {
+                return auth(config.roomId).then(function(param) {
                     var token = param.token;
-                    if (state.connection.state !== "authenticating") {
+                    if (state.connection.current.state !== "authenticating") {
                         return;
                     }
-                    var parsedToken2 = _chunkQLMVHHAZjs.parseRoomAuthToken.call(void 0, token);
+                    var parsedToken2 = _chunkZNCSOBAXjs.parseRoomAuthToken.call(void 0, token);
                     var socket = createWebSocket(token);
                     authenticationSuccess(parsedToken2, socket);
                     state.token = token;
@@ -1655,6 +1798,17 @@ function makeStateMachine(state, context, mockedEffects) {
             return setTimeout(connect, delay);
         }
     };
+    var self = new DerivedRef([
+        state.connection,
+        state.me
+    ], function(conn, me) {
+        return isConnectionSelfAware(conn) ? {
+            connectionId: conn.id,
+            id: conn.userId,
+            info: conn.userInfo,
+            presence: me
+        } : null;
+    });
     var _getInitialStatePromise = null;
     var _getInitialStateResolver = null;
     return {
@@ -1670,7 +1824,7 @@ function makeStateMachine(state, context, mockedEffects) {
             return state.undoStack;
         },
         getItemsCount: function() {
-            return state.items.size;
+            return state.nodes.size;
         },
         connect: connect,
         disconnect: disconnect,
@@ -1685,31 +1839,37 @@ function makeStateMachine(state, context, mockedEffects) {
         pauseHistory: pauseHistory,
         resumeHistory: resumeHistory,
         getStorage: getStorage,
-        selectors: {
-            getConnectionState: getConnectionState,
-            getSelf: getSelf,
-            getPresence: getPresence,
-            getOthers: getOthers
-        }
+        getStorageSnapshot: getStorageSnapshot,
+        events: {
+            customEvent: eventHub.customEvent.observable,
+            others: eventHub.others.observable,
+            me: eventHub.me.observable,
+            error: eventHub.error.observable,
+            connection: eventHub.connection.observable,
+            storage: eventHub.storage.observable,
+            history: eventHub.history.observable,
+            storageDidLoad: eventHub.storageDidLoad.observable
+        },
+        getConnectionState: getConnectionState,
+        isSelfAware: function() {
+            return isConnectionSelfAware(state.connection.current);
+        },
+        getSelf: function() {
+            return self.current;
+        },
+        getPresence: getPresence,
+        getOthers: getOthers
     };
 }
 function defaultState(initialPresence, initialStorage) {
+    var others = new OthersRef();
+    var connection = new ValueRef({
+        state: "closed"
+    });
     return {
-        connection: {
-            state: "closed"
-        },
         token: null,
         lastConnectionId: null,
         socket: null,
-        listeners: {
-            event: [],
-            others: [],
-            "my-presence": [],
-            error: [],
-            connection: [],
-            storage: [],
-            history: []
-        },
         numberOfRetry: 0,
         lastFlushTime: 0,
         timeoutHandles: {
@@ -1718,9 +1878,9 @@ function defaultState(initialPresence, initialStorage) {
             pongTimeout: 0
         },
         buffer: {
-            presence: {
+            me: {
                 type: "full",
-                data: initialPresence == null ? {} : initialPresence
+                data: initialPresence
             },
             messages: [],
             storageOperations: []
@@ -1728,14 +1888,14 @@ function defaultState(initialPresence, initialStorage) {
         intervalHandles: {
             heartbeat: 0
         },
-        me: initialPresence == null ? {} : initialPresence,
-        users: {},
-        others: makeOthers({}),
+        connection: connection,
+        me: new MeRef(initialPresence),
+        others: others,
         defaultStorageRoot: initialStorage,
         idFactory: null,
         clock: 0,
         opClock: 0,
-        items: /* @__PURE__ */ new Map(),
+        nodes: /* @__PURE__ */ new Map(),
         root: void 0,
         undoStack: [],
         redoStack: [],
@@ -1754,25 +1914,23 @@ function defaultState(initialPresence, initialStorage) {
         offlineOperations: /* @__PURE__ */ new Map()
     };
 }
-function createRoom(options, context) {
-    var initialPresence = _nullishCoalesce(options.initialPresence, function() {
-        return options.defaultPresence;
-    });
-    var initialStorage = _nullishCoalesce(options.initialStorage, function() {
-        return options.defaultStorageRoot;
-    });
-    var state = defaultState(typeof initialPresence === "function" ? initialPresence(context.roomId) : initialPresence, typeof initialStorage === "function" ? initialStorage(context.roomId) : initialStorage);
-    var machine = makeStateMachine(state, context);
+function createRoom(options, config) {
+    var initialPresence = options.initialPresence, initialStorage = options.initialStorage;
+    var state = defaultState(typeof initialPresence === "function" ? initialPresence(config.roomId) : initialPresence, typeof initialStorage === "function" ? initialStorage(config.roomId) : initialStorage);
+    var machine = makeStateMachine(state, config);
     var room = {
-        id: context.roomId,
-        getConnectionState: machine.selectors.getConnectionState,
-        getSelf: machine.selectors.getSelf,
+        id: config.roomId,
+        getConnectionState: machine.getConnectionState,
+        isSelfAware: machine.isSelfAware,
+        getSelf: machine.getSelf,
         subscribe: machine.subscribe,
-        getPresence: machine.selectors.getPresence,
+        getPresence: machine.getPresence,
         updatePresence: machine.updatePresence,
-        getOthers: machine.selectors.getOthers,
+        getOthers: machine.getOthers,
         broadcastEvent: machine.broadcastEvent,
         getStorage: machine.getStorage,
+        getStorageSnapshot: machine.getStorageSnapshot,
+        events: machine.events,
         batch: machine.batch,
         history: {
             undo: machine.undo,
@@ -1813,7 +1971,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
     }
     var ws = WebSocketPolyfill || WebSocket;
     return function(token) {
-        return new ws("".concat(liveblocksServer, "/?token=").concat(token, "&version=").concat(true ? "0.17.11-debug2" : "dev"));
+        return new ws("".concat(liveblocksServer, "/?token=").concat(token, "&version=").concat(true ? "0.18.0-beta1" : "dev"));
     };
 }
 function prepareAuthEndpoint(authentication, fetchPolyfill) {
@@ -1866,7 +2024,7 @@ function fetchAuthEndpoint(fetch2, endpoint, body) {
             throw new AuthenticationError('Expected a JSON response when doing a POST request on "'.concat(endpoint, '". ').concat(er));
         });
     }).then(function(data) {
-        if (!_chunkQLMVHHAZjs.isPlainObject.call(void 0, data) || typeof data.token !== "string") {
+        if (!_chunkZNCSOBAXjs.isPlainObject.call(void 0, data) || typeof data.token !== "string") {
             throw new AuthenticationError('Expected a JSON response of the form `{ token: "..." }` when doing a POST request on "'.concat(endpoint, '", but got ').concat(JSON.stringify(data)));
         }
         var token = data.token;
@@ -1890,19 +2048,17 @@ function createClient(options) {
         var internalRoom = rooms.get(roomId);
         return internalRoom ? internalRoom.room : null;
     };
-    var enter = function enter(roomId) {
-        var options2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var enter = function enter(roomId, options2) {
         var internalRoom = rooms.get(roomId);
         if (internalRoom) {
             return internalRoom.room;
         }
-        _chunkQLMVHHAZjs.errorIf.call(void 0, options2.defaultPresence, "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP");
-        _chunkQLMVHHAZjs.errorIf.call(void 0, options2.defaultStorageRoot, "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP");
+        _chunkZNCSOBAXjs.deprecateIf.call(void 0, options2.initialPresence == null, "Please provide an initial presence value for the current user when entering the room.");
         internalRoom = createRoom({
-            initialPresence: options2.initialPresence,
-            initialStorage: options2.initialStorage,
-            defaultPresence: options2.defaultPresence,
-            defaultStorageRoot: options2.defaultStorageRoot
+            initialPresence: _nullishCoalesce(options2.initialPresence, function() {
+                return {};
+            }),
+            initialStorage: options2.initialStorage
         }, {
             roomId: roomId,
             throttleDelay: throttleDelay,
@@ -2051,7 +2207,46 @@ function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
     }
     return "https://api.liveblocks.io/v2/rooms/".concat(encodeURIComponent(roomId), "/public/authorize");
 }
-exports.LiveList = _chunkQLMVHHAZjs.LiveList;
-exports.LiveMap = _chunkQLMVHHAZjs.LiveMap;
-exports.LiveObject = _chunkQLMVHHAZjs.LiveObject;
+// src/shallow.ts
+function shallowArray(xs, ys) {
+    if (xs.length !== ys.length) {
+        return false;
+    }
+    for(var i = 0; i < xs.length; i++){
+        if (!Object.is(xs[i], ys[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function shallowObj(objA, objB) {
+    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null || Object.prototype.toString.call(objA) !== "[object Object]" || Object.prototype.toString.call(objB) !== "[object Object]") {
+        return false;
+    }
+    var keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
+        return false;
+    }
+    return keysA.every(function(key) {
+        return Object.prototype.hasOwnProperty.call(objB, key) && Object.is(objA[key], objB[key]);
+    });
+}
+function shallow(a, b) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    var isArrayA = Array.isArray(a);
+    var isArrayB = Array.isArray(b);
+    if (isArrayA || isArrayB) {
+        if (!isArrayA || !isArrayB) {
+            return false;
+        }
+        return shallowArray(a, b);
+    }
+    return shallowObj(a, b);
+}
+exports.LiveList = _chunkZNCSOBAXjs.LiveList;
+exports.LiveMap = _chunkZNCSOBAXjs.LiveMap;
+exports.LiveObject = _chunkZNCSOBAXjs.LiveObject;
 exports.createClient = createClient;
+exports.shallow = shallow;