@liveblocks/core 1.0.2 → 1.0.6-test2

package/dist/index.js

@@ -72,10 +72,12 @@ function makeEventSource() {
     _observers.clear();
   }
   return {
+    // Private/internal control over event emission
     notify,
     subscribe,
     subscribeOnce,
     clear,
+    // Publicly exposable subscription API
     observable: {
       subscribe,
       subscribeOnce
@@ -113,7 +115,10 @@ if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
 var onMessageFromPanel = eventSource.observable;
 
 // src/devtools/index.ts
-var VERSION = true ? "1.0.2" : "dev";
+var VERSION = true ? (
+  /* istanbul ignore next */
+  "1.0.6-test2"
+) : "dev";
 var _devtoolsSetupHasRun = false;
 function setupDevTools(getAllRooms) {
   if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
@@ -153,9 +158,13 @@ function startSyncStream(room) {
   stopSyncStream(room.id);
   fullSync(room);
   unsubsByRoomId.set(room.id, [
+    // When the connection status changes
     room.events.connection.subscribe(() => partialSyncConnection(room)),
+    // When storage initializes, send the update
     room.events.storageDidLoad.subscribeOnce(() => partialSyncStorage(room)),
+    // Any time storage updates, send the new storage root
     room.events.storage.subscribe(() => partialSyncStorage(room)),
+    // Any time "me" or "others" updates, send the new values accordingly
     room.events.me.subscribe(() => partialSyncMe(room)),
     room.events.others.subscribe(() => partialSyncOthers(room))
   ]);
@@ -178,7 +187,7 @@ function partialSyncStorage(room) {
   }
 }
 function partialSyncMe(room) {
-  const me = room.getSelf_forDevTools();
+  const me = room.__internal.getSelf_forDevTools();
   if (me) {
     sendToPanel({
       msg: "room::sync::partial",
@@ -188,7 +197,7 @@ function partialSyncMe(room) {
   }
 }
 function partialSyncOthers(room) {
-  const others = room.getOthers_forDevTools();
+  const others = room.__internal.getOthers_forDevTools();
   if (others) {
     sendToPanel({
       msg: "room::sync::partial",
@@ -200,8 +209,8 @@ function partialSyncOthers(room) {
 function fullSync(room) {
   var _a;
   const root = room.getStorageSnapshot();
-  const me = room.getSelf_forDevTools();
-  const others = room.getOthers_forDevTools();
+  const me = room.__internal.getSelf_forDevTools();
+  const others = room.__internal.getOthers_forDevTools();
   sendToPanel({
     msg: "room::sync::full",
     roomId: room.id,
@@ -227,6 +236,8 @@ function linkDevTools(roomId, room) {
   stopRoomChannelListener(roomId);
   roomChannelListeners.set(
     roomId,
+    // Returns the unsubscribe callback, that we store in the
+    // roomChannelListeners registry
     onMessageFromPanel.subscribe((msg) => {
       switch (msg.msg) {
         case "room::subscribe": {
@@ -261,17 +272,23 @@ function unlinkDevTools(roomId) {
 var badge = "background:#0e0d12;border-radius:9999px;color:#fff;padding:3px 7px;font-family:sans-serif;font-weight:600;";
 var bold = "font-weight:600";
 function wrap(method) {
-  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (message, ...args) => console[method]("%cLiveblocks", badge, message, ...args);
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (
+    /* istanbul ignore next */
+    (message, ...args) => console[method]("%cLiveblocks", badge, message, ...args)
+  );
 }
 var warn = wrap("warn");
 var error = wrap("error");
 function wrapWithTitle(method) {
-  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (title, message, ...args) => console[method](
-    `%cLiveblocks%c ${title}`,
-    badge,
-    bold,
-    message,
-    ...args
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (
+    /* istanbul ignore next */
+    (title, message, ...args) => console[method](
+      `%cLiveblocks%c ${title}`,
+      badge,
+      bold,
+      message,
+      ...args
+    )
   );
 }
 var warnWithTitle = wrapWithTitle("warn");
@@ -358,8 +375,10 @@ function Orphaned(oldKey) {
 }
 var AbstractCrdt = class {
   constructor() {
+    /** @internal */
     this._parent = NoParent;
   }
+  /** @internal */
   _getParentKeyOrThrow() {
     switch (this.parent.type) {
       case "HasParent":
@@ -372,18 +391,22 @@ var AbstractCrdt = class {
         return assertNever(this.parent, "Unknown state");
     }
   }
+  /** @internal */
   get _pool() {
     return this.__pool;
   }
   get roomId() {
     return this.__pool ? this.__pool.roomId : null;
   }
+  /** @internal */
   get _id() {
     return this.__id;
   }
+  /** @internal */
   get parent() {
     return this._parent;
   }
+  /** @internal */
   get _parentNode() {
     switch (this.parent.type) {
       case "HasParent":
@@ -396,6 +419,7 @@ var AbstractCrdt = class {
         return assertNever(this.parent, "Unknown state");
     }
   }
+  /** @internal */
   get _parentKey() {
     switch (this.parent.type) {
       case "HasParent":
@@ -408,6 +432,7 @@ var AbstractCrdt = class {
         return assertNever(this.parent, "Unknown state");
     }
   }
+  /** @internal */
   _apply(op, _isLocal) {
     switch (op.type) {
       case 5 /* DELETE_CRDT */: {
@@ -419,6 +444,7 @@ var AbstractCrdt = class {
     }
     return { modified: false };
   }
+  /** @internal */
   _setParentLink(newParentNode, newParentKey) {
     switch (this.parent.type) {
       case "HasParent":
@@ -437,6 +463,7 @@ var AbstractCrdt = class {
         return assertNever(this.parent, "Unknown state");
     }
   }
+  /** @internal */
   _attach(id, pool) {
     if (this.__id || this.__pool) {
       throw new Error("Cannot attach node: already attached");
@@ -445,6 +472,7 @@ var AbstractCrdt = class {
     this.__id = id;
     this.__pool = pool;
   }
+  /** @internal */
   _detach() {
     if (this.__pool && this.__id) {
       this.__pool.deleteNode(this.__id);
@@ -467,6 +495,13 @@ var AbstractCrdt = class {
     }
     this.__pool = void 0;
   }
+  /**
+   * @internal
+   *
+   * Clear the Immutable cache, so that the next call to `.toImmutable()` will
+   * recompute the equivalent Immutable value again.  Call this after every
+   * mutation to the Live node.
+   */
   invalidate() {
     if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
       this._cachedImmutable = void 0;
@@ -476,6 +511,11 @@ var AbstractCrdt = class {
       }
     }
   }
+  /**
+   * @internal
+   *
+   * Return an snapshot of this Live tree for use in DevTools.
+   */
   toTreeNode(key) {
     if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
       this._cachedTreeNodeKey = key;
@@ -483,6 +523,9 @@ var AbstractCrdt = class {
     }
     return this._cachedTreeNode;
   }
+  /**
+   * Return an immutable snapshot of this Live node and its children.
+   */
   toImmutable() {
     if (this._cachedImmutable === void 0) {
       this._cachedImmutable = this._toImmutable();
@@ -679,11 +722,13 @@ var LiveRegister = class extends AbstractCrdt {
   get data() {
     return this._data;
   }
+  /** @internal */
   static _deserialize([id, item], _parentToChildren, pool) {
     const register = new LiveRegister(item.data);
     register._attach(id, pool);
     return register;
   }
+  /** @internal */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error(
@@ -701,6 +746,7 @@ var LiveRegister = class extends AbstractCrdt {
       }
     ];
   }
+  /** @internal */
   _serialize() {
     if (this.parent.type !== "HasParent") {
       throw new Error("Cannot serialize LiveRegister if parent is missing");
@@ -712,15 +758,19 @@ var LiveRegister = class extends AbstractCrdt {
       data: this.data
     };
   }
+  /** @internal */
   _attachChild(_op) {
     throw new Error("Method not implemented.");
   }
+  /** @internal */
   _detachChild(_crdt) {
     throw new Error("Method not implemented.");
   }
+  /** @internal */
   _apply(op, isLocal) {
     return super._apply(op, isLocal);
   }
+  /** @internal */
   _toTreeNode(key) {
     var _a;
     return {
@@ -730,6 +780,7 @@ var LiveRegister = class extends AbstractCrdt {
       payload: this._data
     };
   }
+  /** @internal */
   _toImmutable() {
     return this._data;
   }
@@ -757,6 +808,7 @@ var LiveList = class extends AbstractCrdt {
       position = newPosition;
     }
   }
+  /** @internal */
   static _deserialize([id], parentToChildren, pool) {
     const list = new LiveList();
     list._attach(id, pool);
@@ -771,6 +823,7 @@ var LiveList = class extends AbstractCrdt {
     }
     return list;
   }
+  /** @internal */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
@@ -789,31 +842,41 @@ var LiveList = class extends AbstractCrdt {
     }
     return ops;
   }
+  /**
+   * @internal
+   *
+   * Adds a new item into the sorted list, in the correct position.
+   */
   _insertAndSort(item) {
     this._items.push(item);
     this._sortItems();
   }
+  /** @internal */
   _sortItems() {
     this._items.sort(compareNodePosition);
     this.invalidate();
   }
+  /** @internal */
   _indexOfPosition(position) {
     return this._items.findIndex(
       (item) => item._getParentKeyOrThrow() === position
     );
   }
+  /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
     for (const item of this._items) {
       item._attach(pool.generateId(), pool);
     }
   }
+  /** @internal */
   _detach() {
     super._detach();
     for (const item of this._items) {
       item._detach();
     }
   }
+  /** @internal */
   _applySetRemote(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -868,6 +931,7 @@ var LiveList = class extends AbstractCrdt {
       };
     }
   }
+  /** @internal */
   _applySetAck(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -921,6 +985,7 @@ var LiveList = class extends AbstractCrdt {
         const recreatedItemIndex = this._items.indexOf(orphan);
         return {
           modified: makeUpdate(this, [
+            // If there is an item at this position, update is a set, else it's an insert
             indexOfItemWithSamePosition === -1 ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan),
             ...delta
           ]),
@@ -936,6 +1001,7 @@ var LiveList = class extends AbstractCrdt {
         );
         return {
           modified: makeUpdate(this, [
+            // If there is an item at this position, update is a set, else it's an insert
             indexOfItemWithSamePosition === -1 ? insertDelta(newIndex, newItem) : setDelta(newIndex, newItem),
             ...delta
           ]),
@@ -944,6 +1010,10 @@ var LiveList = class extends AbstractCrdt {
       }
     }
   }
+  /**
+   * Returns the update delta of the deletion or null
+   * @internal
+   */
   _detachItemAssociatedToSetOperation(deletedId) {
     if (deletedId === void 0 || this._pool === void 0) {
       return null;
@@ -958,6 +1028,7 @@ var LiveList = class extends AbstractCrdt {
     }
     return result.modified.updates[0];
   }
+  /** @internal */
   _applyRemoteInsert(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -973,6 +1044,7 @@ var LiveList = class extends AbstractCrdt {
       reverse: []
     };
   }
+  /** @internal */
   _applyInsertAck(op) {
     const existingItem = this._items.find((item) => item._id === op.id);
     const key = op.parentKey;
@@ -1023,6 +1095,7 @@ var LiveList = class extends AbstractCrdt {
       }
     }
   }
+  /** @internal */
   _applyInsertUndoRedo(op) {
     var _a, _b, _c;
     const { id, parentKey: key } = op;
@@ -1047,6 +1120,7 @@ var LiveList = class extends AbstractCrdt {
       reverse: [{ type: 5 /* DELETE_CRDT */, id }]
     };
   }
+  /** @internal */
   _applySetUndoRedo(op) {
     var _a;
     const { id, parentKey: key } = op;
@@ -1088,6 +1162,7 @@ var LiveList = class extends AbstractCrdt {
       };
     }
   }
+  /** @internal */
   _attachChild(op, source) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -1115,6 +1190,7 @@ var LiveList = class extends AbstractCrdt {
     }
     return result;
   }
+  /** @internal */
   _detachChild(child) {
     if (child) {
       const parentKey = nn(child._parentKey);
@@ -1135,6 +1211,7 @@ var LiveList = class extends AbstractCrdt {
     }
     return { modified: false };
   }
+  /** @internal */
   _applySetChildKeyRemote(newKey, child) {
     var _a;
     if (this._implicitlyDeletedItems.has(child)) {
@@ -1191,6 +1268,7 @@ var LiveList = class extends AbstractCrdt {
       };
     }
   }
+  /** @internal */
   _applySetChildKeyAck(newKey, child) {
     var _a, _b;
     const previousKey = nn(child._parentKey);
@@ -1245,6 +1323,7 @@ var LiveList = class extends AbstractCrdt {
       }
     }
   }
+  /** @internal */
   _applySetChildKeyUndoRedo(newKey, child) {
     var _a;
     const previousKey = nn(child._parentKey);
@@ -1278,6 +1357,7 @@ var LiveList = class extends AbstractCrdt {
       ]
     };
   }
+  /** @internal */
   _setChildKey(newKey, child, source) {
     if (source === 1 /* REMOTE */) {
       return this._applySetChildKeyRemote(newKey, child);
@@ -1287,9 +1367,11 @@ var LiveList = class extends AbstractCrdt {
       return this._applySetChildKeyUndoRedo(newKey, child);
     }
   }
+  /** @internal */
   _apply(op, isLocal) {
     return super._apply(op, isLocal);
   }
+  /** @internal */
   _serialize() {
     if (this.parent.type !== "HasParent") {
       throw new Error("Cannot serialize LiveList if parent is missing");
@@ -1300,14 +1382,26 @@ var LiveList = class extends AbstractCrdt {
       parentKey: this.parent.key
     };
   }
+  /**
+   * Returns the number of elements.
+   */
   get length() {
     return this._items.length;
   }
+  /**
+   * Adds one element to the end of the LiveList.
+   * @param element The element to add to the end of the LiveList.
+   */
   push(element) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     return this.insert(element, this.length);
   }
+  /**
+   * Inserts one element at a specified index.
+   * @param element The element to insert.
+   * @param index The index at which you want to insert the element.
+   */
   insert(element, index) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -1334,6 +1428,11 @@ var LiveList = class extends AbstractCrdt {
       );
     }
   }
+  /**
+   * Move one element from one index to another.
+   * @param index The index of the element to move
+   * @param targetIndex The index where the element should be after moving.
+   */
   move(index, targetIndex) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -1389,6 +1488,10 @@ var LiveList = class extends AbstractCrdt {
       );
     }
   }
+  /**
+   * Deletes an element at the specified index
+   * @param index The index of the element to delete
+   */
   delete(index) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -1491,52 +1594,111 @@ var LiveList = class extends AbstractCrdt {
       this._pool.dispatch(ops, reverseOps, storageUpdates);
     }
   }
+  /**
+   * Returns an Array of all the elements in the LiveList.
+   */
   toArray() {
     return this._items.map(
       (entry) => liveNodeToLson(entry)
+      //                               ^^^^^^^^
+      //                               FIXME! This isn't safe.
     );
   }
+  /**
+   * Tests whether all elements pass the test implemented by the provided function.
+   * @param predicate Function to test for each element, taking two arguments (the element and its index).
+   * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
+   */
   every(predicate) {
     return this.toArray().every(predicate);
   }
+  /**
+   * Creates an array with all elements that pass the test implemented by the provided function.
+   * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
+   * @returns An array with the elements that pass the test.
+   */
   filter(predicate) {
     return this.toArray().filter(predicate);
   }
+  /**
+   * Returns the first element that satisfies the provided testing function.
+   * @param predicate Function to execute on each value.
+   * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
+   */
   find(predicate) {
     return this.toArray().find(predicate);
   }
+  /**
+   * Returns the index of the first element in the LiveList that satisfies the provided testing function.
+   * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
+   * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
+   */
   findIndex(predicate) {
     return this.toArray().findIndex(predicate);
   }
+  /**
+   * Executes a provided function once for each element.
+   * @param callbackfn Function to execute on each element.
+   */
   forEach(callbackfn) {
     return this.toArray().forEach(callbackfn);
   }
+  /**
+   * Get the element at the specified index.
+   * @param index The index on the element to get.
+   * @returns The element at the specified index or undefined.
+   */
   get(index) {
     if (index < 0 || index >= this._items.length) {
       return void 0;
     }
     return liveNodeToLson(this._items[index]);
   }
+  /**
+   * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
+   * @param searchElement Element to locate.
+   * @param fromIndex The index to start the search at.
+   * @returns The first index of the element in the LiveList; -1 if not found.
+   */
   indexOf(searchElement, fromIndex) {
     return this.toArray().indexOf(searchElement, fromIndex);
   }
+  /**
+   * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
+   * @param searchElement Element to locate.
+   * @param fromIndex The index at which to start searching backwards.
+   * @returns
+   */
   lastIndexOf(searchElement, fromIndex) {
     return this.toArray().lastIndexOf(searchElement, fromIndex);
   }
+  /**
+   * Creates an array populated with the results of calling a provided function on every element.
+   * @param callback Function that is called for every element.
+   * @returns An array with each element being the result of the callback function.
+   */
   map(callback) {
     return this._items.map(
       (entry, i) => callback(
         liveNodeToLson(entry),
+        //                    ^^^^^^^^
+        //                    FIXME! This isn't safe.
         i
       )
     );
   }
+  /**
+   * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
+   * @param predicate Function to test for each element.
+   * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
+   */
   some(predicate) {
     return this.toArray().some(predicate);
   }
   [Symbol.iterator]() {
     return new LiveListIterator(this._items);
   }
+  /** @internal */
   _createAttachItemAndSort(op, key) {
     const newItem = creationOpToLiveNode(op);
     newItem._attach(op.id, nn(this._pool));
@@ -1545,6 +1707,7 @@ var LiveList = class extends AbstractCrdt {
     const newIndex = this._indexOfPosition(key);
     return { newItem, newIndex };
   }
+  /** @internal */
   _shiftItemPosition(index, key) {
     var _a;
     const shiftedPosition = makePosition(
@@ -1553,6 +1716,7 @@ var LiveList = class extends AbstractCrdt {
     );
     this._items[index]._setParentLink(this, shiftedPosition);
   }
+  /** @internal */
   _toTreeNode(key) {
     var _a;
     return {
@@ -1567,6 +1731,7 @@ var LiveList = class extends AbstractCrdt {
   toImmutable() {
     return super.toImmutable();
   }
+  /** @internal */
   _toImmutable() {
     const result = this._items.map((node) => node.toImmutable());
     return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
@@ -1641,7 +1806,10 @@ function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
 }
 
 // src/lib/freeze.ts
-var freeze = process.env.NODE_ENV === "production" ? (x) => x : Object.freeze;
+var freeze = process.env.NODE_ENV === "production" ? (
+  /* istanbul ignore next */
+  (x) => x
+) : Object.freeze;
 
 // src/crdts/LiveMap.ts
 var LiveMap = class extends AbstractCrdt {
@@ -1660,6 +1828,9 @@ var LiveMap = class extends AbstractCrdt {
       this._map = /* @__PURE__ */ new Map();
     }
   }
+  /**
+   * @internal
+   */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
@@ -1678,6 +1849,9 @@ var LiveMap = class extends AbstractCrdt {
     }
     return ops;
   }
+  /**
+   * @internal
+   */
   static _deserialize([id, _item], parentToChildren, pool) {
     const map = new LiveMap();
     map._attach(id, pool);
@@ -1693,6 +1867,9 @@ var LiveMap = class extends AbstractCrdt {
     }
     return map;
   }
+  /**
+   * @internal
+   */
   _attach(id, pool) {
     super._attach(id, pool);
     for (const [_key, value] of this._map) {
@@ -1701,6 +1878,9 @@ var LiveMap = class extends AbstractCrdt {
       }
     }
   }
+  /**
+   * @internal
+   */
   _attachChild(op, source) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -1744,12 +1924,18 @@ var LiveMap = class extends AbstractCrdt {
       reverse
     };
   }
+  /**
+   * @internal
+   */
   _detach() {
     super._detach();
     for (const item of this._map.values()) {
       item._detach();
     }
   }
+  /**
+   * @internal
+   */
   _detachChild(child) {
     const id = nn(this._id);
     const parentKey = nn(child._parentKey);
@@ -1768,6 +1954,9 @@ var LiveMap = class extends AbstractCrdt {
     };
     return { modified: storageUpdate, reverse };
   }
+  /**
+   * @internal
+   */
   _serialize() {
     if (this.parent.type !== "HasParent") {
       throw new Error("Cannot serialize LiveMap if parent is missing");
@@ -1778,6 +1967,11 @@ var LiveMap = class extends AbstractCrdt {
       parentKey: this.parent.key
     };
   }
+  /**
+   * Returns a specified element from the LiveMap.
+   * @param key The key of the element to return.
+   * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
+   */
   get(key) {
     const value = this._map.get(key);
     if (value === void 0) {
@@ -1785,6 +1979,11 @@ var LiveMap = class extends AbstractCrdt {
     }
     return liveNodeToLson(value);
   }
+  /**
+   * Adds or updates an element with a specified key and a value.
+   * @param key The key of the element to add. Should be a string.
+   * @param value The value of the element to add. Should be serializable to JSON.
+   */
   set(key, value) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -1814,12 +2013,24 @@ var LiveMap = class extends AbstractCrdt {
       );
     }
   }
+  /**
+   * Returns the number of elements in the LiveMap.
+   */
   get size() {
     return this._map.size;
   }
+  /**
+   * Returns a boolean indicating whether an element with the specified key exists or not.
+   * @param key The key of the element to test for presence.
+   */
   has(key) {
     return this._map.has(key);
   }
+  /**
+   * Removes the specified element by key.
+   * @param key The key of the element to remove.
+   * @returns true if an element existed and has been removed, or false if the element does not exist.
+   */
   delete(key) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -1852,6 +2063,9 @@ var LiveMap = class extends AbstractCrdt {
     }
     return true;
   }
+  /**
+   * Returns a new Iterator object that contains the [key, value] pairs for each element.
+   */
   entries() {
     const innerIterator = this._map.entries();
     return {
@@ -1875,12 +2089,21 @@ var LiveMap = class extends AbstractCrdt {
       }
     };
   }
+  /**
+   * Same function object as the initial value of the entries method.
+   */
   [Symbol.iterator]() {
     return this.entries();
   }
+  /**
+   * Returns a new Iterator object that contains the keys for each element.
+   */
   keys() {
     return this._map.keys();
   }
+  /**
+   * Returns a new Iterator object that contains the values for each element.
+   */
   values() {
     const innerIterator = this._map.values();
     return {
@@ -1900,11 +2123,16 @@ var LiveMap = class extends AbstractCrdt {
       }
     };
   }
+  /**
+   * Executes a provided function once per each key/value pair in the Map object, in insertion order.
+   * @param callback Function to execute for each entry in the map.
+   */
   forEach(callback) {
     for (const entry of this) {
       callback(entry[1], entry[0], this);
     }
   }
+  /** @internal */
   _toTreeNode(key) {
     var _a;
     return {
@@ -1919,6 +2147,7 @@ var LiveMap = class extends AbstractCrdt {
   toImmutable() {
     return super.toImmutable();
   }
+  /** @internal */
   _toImmutable() {
     const result = /* @__PURE__ */ new Map();
     for (const [key, value] of this._map) {
@@ -1943,6 +2172,7 @@ var LiveObject = class extends AbstractCrdt {
     }
     this._map = new Map(Object.entries(obj));
   }
+  /** @internal */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
@@ -1956,7 +2186,10 @@ var LiveObject = class extends AbstractCrdt {
       parentId,
       parentKey,
       data: {}
-    } : { type: 4 /* CREATE_OBJECT */, id: this._id, opId, data: {} };
+    } : (
+      // Root object
+      { type: 4 /* CREATE_OBJECT */, id: this._id, opId, data: {} }
+    );
     ops.push(op);
     for (const [key, value] of this._map) {
       if (isLiveNode(value)) {
@@ -1967,11 +2200,13 @@ var LiveObject = class extends AbstractCrdt {
     }
     return ops;
   }
+  /** @internal */
   static _deserialize([id, item], parentToChildren, pool) {
     const liveObj = new LiveObject(item.data);
     liveObj._attach(id, pool);
     return this._deserializeChildren(liveObj, parentToChildren, pool);
   }
+  /** @internal */
   static _deserializeChildren(liveObj, parentToChildren, pool) {
     const children = parentToChildren.get(nn(liveObj._id));
     if (children === void 0) {
@@ -1987,6 +2222,7 @@ var LiveObject = class extends AbstractCrdt {
     }
     return liveObj;
   }
+  /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
     for (const [_key, value] of this._map) {
@@ -1995,6 +2231,7 @@ var LiveObject = class extends AbstractCrdt {
       }
     }
   }
+  /** @internal */
   _attachChild(op, source) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -2048,6 +2285,7 @@ var LiveObject = class extends AbstractCrdt {
       }
     };
   }
+  /** @internal */
   _detachChild(child) {
     if (child) {
       const id = nn(this._id);
@@ -2071,6 +2309,9 @@ var LiveObject = class extends AbstractCrdt {
     }
     return { modified: false };
   }
+  /**
+   * @internal
+   */
   _detach() {
     super._detach();
     for (const value of this._map.values()) {
@@ -2079,6 +2320,7 @@ var LiveObject = class extends AbstractCrdt {
       }
     }
   }
+  /** @internal */
   _apply(op, isLocal) {
     if (op.type === 3 /* UPDATE_OBJECT */) {
       return this._applyUpdate(op, isLocal);
@@ -2087,6 +2329,9 @@ var LiveObject = class extends AbstractCrdt {
     }
     return super._apply(op, isLocal);
   }
+  /**
+   * @internal
+   */
   _serialize() {
     const data = {};
     for (const [key, value] of this._map) {
@@ -2108,6 +2353,7 @@ var LiveObject = class extends AbstractCrdt {
       };
     }
   }
+  /** @internal */
   _applyUpdate(op, isLocal) {
     let isModified = false;
     const id = nn(this._id);
@@ -2166,6 +2412,7 @@ var LiveObject = class extends AbstractCrdt {
       reverse
     } : { modified: false };
   }
+  /** @internal */
   _applyDeleteObjectKey(op, isLocal) {
     const key = op.key;
     if (this._map.has(key) === false) {
@@ -2200,17 +2447,33 @@ var LiveObject = class extends AbstractCrdt {
       reverse
     };
   }
+  /**
+   * Transform the LiveObject into a javascript object
+   */
   toObject() {
     return fromEntries(this._map);
   }
+  /**
+   * Adds or updates a property with a specified key and a value.
+   * @param key The key of the property to add
+   * @param value The value of the property to add
+   */
   set(key, value) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
     this.update({ [key]: value });
   }
+  /**
+   * Returns a specified property from the LiveObject.
+   * @param key The key of the property to get
+   */
   get(key) {
     return this._map.get(key);
   }
+  /**
+   * Deletes a key from the LiveObject
+   * @param key The key of the property to delete
+   */
   delete(key) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -2261,6 +2524,10 @@ var LiveObject = class extends AbstractCrdt {
       storageUpdates
     );
   }
+  /**
+   * Adds or updates multiple properties at once with an object.
+   * @param patch The object used to overrides properties
+   */
   update(patch) {
     var _a;
     (_a = this._pool) == null ? void 0 : _a.assertStorageIsWritable();
@@ -2347,9 +2614,11 @@ var LiveObject = class extends AbstractCrdt {
   toImmutable() {
     return super.toImmutable();
   }
+  /** @internal */
   toTreeNode(key) {
     return super.toTreeNode(key);
   }
+  /** @internal */
   _toTreeNode(key) {
     var _a;
     const nodeId = (_a = this._id) != null ? _a : nanoid();
@@ -2362,6 +2631,7 @@ var LiveObject = class extends AbstractCrdt {
       )
     };
   }
+  /** @internal */
   _toImmutable() {
     const result = {};
     for (const [key, val] of this._map) {
@@ -2526,7 +2796,10 @@ function getTreesDiffOperations(currentItems, newItems) {
               parentId: crdt.parentId,
               parentKey: crdt.parentKey,
               data: crdt.data
-            } : { type: 4 /* CREATE_OBJECT */, id, data: crdt.data }
+            } : (
+              // Root object
+              { type: 4 /* CREATE_OBJECT */, id, data: crdt.data }
+            )
           );
           break;
         case 2 /* MAP */:
@@ -2567,7 +2840,7 @@ function mergeListStorageUpdates(first, second) {
   });
 }
 function mergeStorageUpdates(first, second) {
-  if (!first) {
+  if (first === void 0) {
     return second;
   }
   if (first.type === "LiveObject" && second.type === "LiveObject") {
@@ -2678,6 +2951,8 @@ function parseRoomAuthToken(tokenString) {
     const _a = data, {
       maxConnections: _legacyField
     } = _a, token = __objRest(_a, [
+      // If this legacy field is found on the token, pretend it wasn't there,
+      // to make all internally used token payloads uniform
       "maxConnections"
     ]);
     return token;
@@ -2753,9 +3028,13 @@ var MeRef = class extends ImmutableRef {
     super();
     this._me = freeze(compactObject(initialPresence));
   }
+  /** @internal */
   _toImmutable() {
     return this._me;
   }
+  /**
+   * Patches the current "me" instance.
+   */
   patch(patch) {
     const oldMe = this._me;
     const newMe = merge(oldMe, patch);
@@ -2784,12 +3063,16 @@ function makeUser(conn, presence) {
   return freeze(compactObject(__spreadProps(__spreadValues({}, conn), { presence })));
 }
 var OthersRef = class extends ImmutableRef {
+  //
+  // --------------------------------------------------------------
+  //
   constructor() {
     super();
     this._connections = {};
     this._presences = {};
     this._users = {};
   }
+  /** @internal */
   _toImmutable() {
     const users = compact(
       Object.keys(this._presences).map(
@@ -2804,6 +3087,7 @@ var OthersRef = class extends ImmutableRef {
     this._users = {};
     this.invalidate();
   }
+  /** @internal */
   _getUser(connectionId) {
     const conn = this._connections[connectionId];
     const presence = this._presences[connectionId];
@@ -2824,12 +3108,17 @@ var OthersRef = class extends ImmutableRef {
     }
     return void 0;
   }
+  /** @internal */
   _invalidateUser(connectionId) {
     if (this._users[connectionId] !== void 0) {
       delete this._users[connectionId];
     }
     this.invalidate();
   }
+  /**
+   * Records a known connection. This records the connection ID and the
+   * associated metadata.
+   */
   setConnection(connectionId, metaUserId, metaUserInfo, metaIsReadonly) {
     this._connections[connectionId] = freeze({
       connectionId,
@@ -2841,17 +3130,30 @@ var OthersRef = class extends ImmutableRef {
       this._invalidateUser(connectionId);
     }
   }
+  /**
+   * Removes a known connectionId. Removes both the connection's metadata and
+   * the presence information.
+   */
   removeConnection(connectionId) {
     delete this._connections[connectionId];
     delete this._presences[connectionId];
     this._invalidateUser(connectionId);
   }
+  /**
+   * Stores a new user from a full presence update. If the user already exists,
+   * its known presence data is overwritten.
+   */
   setOther(connectionId, presence) {
     this._presences[connectionId] = freeze(compactObject(presence));
     if (this._connections[connectionId] !== void 0) {
       this._invalidateUser(connectionId);
     }
   }
+  /**
+   * Patches the presence data for an existing "other". If we don't know the
+   * initial presence data for this user yet, discard this patch and await the
+   * full .setOther() call first.
+   */
   patchOther(connectionId, patch) {
     const oldPresence = this._presences[connectionId];
     if (oldPresence === void 0) {
@@ -2871,6 +3173,7 @@ var ValueRef = class extends ImmutableRef {
     super();
     this._value = freeze(initialValue);
   }
+  /** @internal */
   _toImmutable() {
     return this._value;
   }
@@ -2890,6 +3193,7 @@ var DerivedRef = class extends ImmutableRef {
     });
     this._transform = transformFn;
   }
+  /** @internal */
   _toImmutable() {
     return this._transform(
       ...this._refs.map((ref) => ref.current)
@@ -2911,9 +3215,6 @@ var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
 })(WebsocketCloseCodes || {});
 
 // src/room.ts
-function isRoomEventName(value) {
-  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history" || value === "storage-status";
-}
 var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
 var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
 var HEARTBEAT_INTERVAL = 3e4;
@@ -2926,7 +3227,7 @@ function log(..._params) {
   return;
 }
 function isConnectionSelfAware(connection) {
-  return connection.state === "open" || connection.state === "connecting";
+  return connection.status === "open" || connection.status === "connecting";
 }
 function userToTreeNode(key, user) {
   return {
@@ -2936,25 +3237,68 @@ function userToTreeNode(key, user) {
     payload: user
   };
 }
-function makeStateMachine(state, config, mockedEffects) {
+function makeStateMachine(config, initialPresence, initialStorage) {
   var _a;
+  const context = {
+    token: null,
+    lastConnectionId: null,
+    socket: null,
+    numberOfRetry: 0,
+    lastFlushTime: 0,
+    timeoutHandles: {
+      flush: void 0,
+      reconnect: void 0,
+      pongTimeout: void 0
+    },
+    buffer: {
+      me: (
+        // Queue up the initial presence message as a Full Presence™ update
+        {
+          type: "full",
+          data: initialPresence
+        }
+      ),
+      messages: [],
+      storageOperations: []
+    },
+    intervalHandles: {
+      heartbeat: void 0
+    },
+    connection: new ValueRef({ status: "closed" }),
+    me: new MeRef(initialPresence),
+    others: new OthersRef(),
+    initialStorage,
+    idFactory: null,
+    // Storage
+    clock: 0,
+    opClock: 0,
+    nodes: /* @__PURE__ */ new Map(),
+    root: void 0,
+    undoStack: [],
+    redoStack: [],
+    pausedHistory: null,
+    activeBatch: null,
+    unacknowledgedOps: /* @__PURE__ */ new Map(),
+    // Debug
+    opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
+  };
   const doNotBatchUpdates = (cb) => cb();
   const batchUpdates = (_a = config.unstable_batchedUpdates) != null ? _a : doNotBatchUpdates;
   const pool = {
     roomId: config.roomId,
-    getNode: (id) => state.nodes.get(id),
-    addNode: (id, node) => void state.nodes.set(id, node),
-    deleteNode: (id) => void state.nodes.delete(id),
-    generateId: () => `${getConnectionId()}:${state.clock++}`,
-    generateOpId: () => `${getConnectionId()}:${state.opClock++}`,
+    getNode: (id) => context.nodes.get(id),
+    addNode: (id, node) => void context.nodes.set(id, node),
+    deleteNode: (id) => void context.nodes.delete(id),
+    generateId: () => `${getConnectionId()}:${context.clock++}`,
+    generateOpId: () => `${getConnectionId()}:${context.opClock++}`,
     dispatch(ops, reverse, storageUpdates) {
-      const activeBatch = state.activeBatch;
+      const activeBatch = context.activeBatch;
       if (process.env.NODE_ENV !== "production") {
         const stackTrace = captureStackTrace("Storage mutation", this.dispatch);
         if (stackTrace) {
           ops.forEach((op) => {
             if (op.opId) {
-              nn(state.opStackTraces).set(op.opId, stackTrace);
+              nn(context.opStackTraces).set(op.opId, stackTrace);
             }
           });
         }
@@ -2974,14 +3318,14 @@ function makeStateMachine(state, config, mockedEffects) {
       } else {
         batchUpdates(() => {
           addToUndoStack(reverse, doNotBatchUpdates);
-          state.redoStack = [];
+          context.redoStack = [];
           dispatchOps(ops);
           notify({ storageUpdates }, doNotBatchUpdates);
         });
       }
     },
     assertStorageIsWritable: () => {
-      if (isConnectionSelfAware(state.connection.current) && state.connection.current.isReadOnly) {
+      if (isConnectionSelfAware(context.connection.current) && context.connection.current.isReadOnly) {
         throw new Error(
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
@@ -2999,23 +3343,22 @@ function makeStateMachine(state, config, mockedEffects) {
     storageDidLoad: makeEventSource(),
     storageStatus: makeEventSource()
   };
-  const effects = mockedEffects || {
+  const effects = config.mockedEffects || {
     authenticate(auth, createWebSocket) {
-      const rawToken = state.token;
-      const parsedToken = rawToken !== null && parseRoomAuthToken(rawToken);
-      if (parsedToken && !isTokenExpired(parsedToken)) {
-        const socket = createWebSocket(rawToken);
-        authenticationSuccess(parsedToken, socket);
+      const prevToken = context.token;
+      if (prevToken !== null && !isTokenExpired(prevToken.parsed)) {
+        const socket = createWebSocket(prevToken.raw);
+        authenticationSuccess(prevToken.parsed, socket);
         return void 0;
       } else {
         return auth(config.roomId).then(({ token }) => {
-          if (state.connection.current.state !== "authenticating") {
+          if (context.connection.current.status !== "authenticating") {
             return;
           }
-          const parsedToken2 = parseRoomAuthToken(token);
+          const parsedToken = parseRoomAuthToken(token);
           const socket = createWebSocket(token);
-          authenticationSuccess(parsedToken2, socket);
-          state.token = token;
+          authenticationSuccess(parsedToken, socket);
+          context.token = { raw: token, parsed: parsedToken };
         }).catch(
           (er) => authenticationFailure(
             er instanceof Error ? er : new Error(String(er))
@@ -3024,10 +3367,10 @@ function makeStateMachine(state, config, mockedEffects) {
       }
     },
     send(messageOrMessages) {
-      if (state.socket === null) {
+      if (context.socket === null) {
         throw new Error("Can't send message if socket is null");
       }
-      state.socket.send(JSON.stringify(messageOrMessages));
+      context.socket.send(JSON.stringify(messageOrMessages));
     },
     delayFlush(delay) {
       return setTimeout(tryFlushing, delay);
@@ -3043,8 +3386,8 @@ function makeStateMachine(state, config, mockedEffects) {
     }
   };
   const self = new DerivedRef(
-    state.connection,
-    state.me,
+    context.connection,
+    context.me,
     (conn, me) => isConnectionSelfAware(conn) ? {
       connectionId: conn.id,
       id: conn.userId,
@@ -3061,14 +3404,14 @@ function makeStateMachine(state, config, mockedEffects) {
     if (message.items.length === 0) {
       throw new Error("Internal error: cannot load storage without items");
     }
-    if (state.root) {
+    if (context.root) {
       updateRoot(message.items, batchedUpdatesWrapper);
     } else {
-      state.root = load(message.items);
+      context.root = load(message.items);
     }
-    for (const key in state.initialStorage) {
-      if (state.root.get(key) === void 0) {
-        state.root.set(key, state.initialStorage[key]);
+    for (const key in context.initialStorage) {
+      if (context.root.get(key) === void 0) {
+        context.root.set(key, context.initialStorage[key]);
       }
     }
   }
@@ -3094,11 +3437,11 @@ function makeStateMachine(state, config, mockedEffects) {
     return [root, parentToChildren];
   }
   function updateRoot(items, batchedUpdatesWrapper) {
-    if (!state.root) {
+    if (!context.root) {
       return;
     }
     const currentItems = /* @__PURE__ */ new Map();
-    state.nodes.forEach((node, id) => {
+    context.nodes.forEach((node, id) => {
       currentItems.set(id, node._serialize());
     });
     const ops = getTreesDiffOperations(currentItems, new Map(items));
@@ -3110,15 +3453,15 @@ function makeStateMachine(state, config, mockedEffects) {
     return LiveObject._deserialize(root, parentToChildren, pool);
   }
   function _addToRealUndoStack(historyOps, batchedUpdatesWrapper) {
-    if (state.undoStack.length >= 50) {
-      state.undoStack.shift();
+    if (context.undoStack.length >= 50) {
+      context.undoStack.shift();
     }
-    state.undoStack.push(historyOps);
+    context.undoStack.push(historyOps);
     onHistoryChange(batchedUpdatesWrapper);
   }
   function addToUndoStack(historyOps, batchedUpdatesWrapper) {
-    if (state.pausedHistory !== null) {
-      state.pausedHistory.unshift(...historyOps);
+    if (context.pausedHistory !== null) {
+      context.pausedHistory.unshift(...historyOps);
     } else {
       _addToRealUndoStack(historyOps, batchedUpdatesWrapper);
     }
@@ -3130,13 +3473,13 @@ function makeStateMachine(state, config, mockedEffects) {
   }, batchedUpdatesWrapper) {
     batchedUpdatesWrapper(() => {
       if (otherEvents.length > 0) {
-        const others = state.others.current;
+        const others = context.others.current;
         for (const event of otherEvents) {
           eventHub.others.notify({ others, event });
         }
       }
       if (presence) {
-        eventHub.me.notify(state.me.current);
+        eventHub.me.notify(context.me.current);
       }
       if (storageUpdates.size > 0) {
         const updates = Array.from(storageUpdates.values());
@@ -3145,11 +3488,11 @@ function makeStateMachine(state, config, mockedEffects) {
     });
   }
   function getConnectionId() {
-    const conn = state.connection.current;
+    const conn = context.connection.current;
     if (isConnectionSelfAware(conn)) {
       return conn.id;
-    } else if (state.lastConnectionId !== null) {
-      return state.lastConnectionId;
+    } else if (context.lastConnectionId !== null) {
+      return context.lastConnectionId;
     }
     throw new Error(
       "Internal. Tried to get connection id but connection was never open"
@@ -3176,14 +3519,14 @@ function makeStateMachine(state, config, mockedEffects) {
           data: {}
         };
         for (const key in op.data) {
-          reverse.data[key] = state.me.current[key];
+          reverse.data[key] = context.me.current[key];
         }
-        state.me.patch(op.data);
-        if (state.buffer.me === null) {
-          state.buffer.me = { type: "partial", data: op.data };
+        context.me.patch(op.data);
+        if (context.buffer.me === null) {
+          context.buffer.me = { type: "partial", data: op.data };
         } else {
           for (const key in op.data) {
-            state.buffer.me.data[key] = op.data[key];
+            context.buffer.me.data[key] = op.data[key];
           }
         }
         output.reverse.unshift(reverse);
@@ -3195,9 +3538,9 @@ function makeStateMachine(state, config, mockedEffects) {
         } else {
           const opId = nn(op.opId);
           if (process.env.NODE_ENV !== "production") {
-            nn(state.opStackTraces).delete(opId);
+            nn(context.opStackTraces).delete(opId);
           }
-          const deleted = state.unacknowledgedOps.delete(opId);
+          const deleted = context.unacknowledgedOps.delete(opId);
           source = deleted ? 2 /* ACK */ : 1 /* REMOTE */;
         }
         const applyOpResult = applyOp(op, source);
@@ -3207,9 +3550,7 @@ function makeStateMachine(state, config, mockedEffects) {
             output.storageUpdates.set(
               nn(applyOpResult.modified.node._id),
               mergeStorageUpdates(
-                output.storageUpdates.get(
-                  nn(applyOpResult.modified.node._id)
-                ),
+                output.storageUpdates.get(nn(applyOpResult.modified.node._id)),
                 applyOpResult.modified
               )
             );
@@ -3239,14 +3580,14 @@ function makeStateMachine(state, config, mockedEffects) {
       case 6 /* DELETE_OBJECT_KEY */:
       case 3 /* UPDATE_OBJECT */:
       case 5 /* DELETE_CRDT */: {
-        const node = state.nodes.get(op.id);
+        const node = context.nodes.get(op.id);
         if (node === void 0) {
           return { modified: false };
         }
         return node._apply(op, source === 0 /* UNDOREDO_RECONNECT */);
       }
       case 1 /* SET_PARENT_KEY */: {
-        const node = state.nodes.get(op.id);
+        const node = context.nodes.get(op.id);
         if (node === void 0) {
           return { modified: false };
         }
@@ -3262,7 +3603,7 @@ function makeStateMachine(state, config, mockedEffects) {
         if (op.parentId === void 0) {
           return { modified: false };
         }
-        const parentNode = state.nodes.get(op.parentId);
+        const parentNode = context.nodes.get(op.parentId);
         if (parentNode === void 0) {
           return { modified: false };
         }
@@ -3270,107 +3611,26 @@ function makeStateMachine(state, config, mockedEffects) {
       }
     }
   }
-  function subscribeToLiveStructureDeeply(node, callback) {
-    return eventHub.storage.subscribe((updates) => {
-      const relatedUpdates = updates.filter(
-        (update) => isSameNodeOrChildOf(update.node, node)
-      );
-      if (relatedUpdates.length > 0) {
-        callback(relatedUpdates);
-      }
-    });
-  }
-  function subscribeToLiveStructureShallowly(node, callback) {
-    return eventHub.storage.subscribe((updates) => {
-      for (const update of updates) {
-        if (update.node._id === node._id) {
-          callback(update.node);
-        }
-      }
-    });
-  }
-  function subscribe(first, second, options) {
-    if (typeof first === "string" && isRoomEventName(first)) {
-      if (typeof second !== "function") {
-        throw new Error("Second argument must be a callback function");
-      }
-      const callback = second;
-      switch (first) {
-        case "event":
-          return eventHub.customEvent.subscribe(
-            callback
-          );
-        case "my-presence":
-          return eventHub.me.subscribe(callback);
-        case "others": {
-          const cb = callback;
-          return eventHub.others.subscribe(
-            ({ others, event }) => 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);
-        case "storage-status":
-          return eventHub.storageStatus.subscribe(
-            callback
-          );
-        default:
-          return assertNever(first, "Unknown event");
-      }
-    }
-    if (second === void 0 || typeof first === "function") {
-      if (typeof first === "function") {
-        const storageCallback = first;
-        return eventHub.storage.subscribe(storageCallback);
-      } else {
-        throw new Error("Please specify a listener callback");
-      }
-    }
-    if (isLiveNode(first)) {
-      const node = first;
-      if (options == null ? void 0 : options.isDeep) {
-        const storageCallback = second;
-        return subscribeToLiveStructureDeeply(node, storageCallback);
-      } else {
-        const nodeCallback = second;
-        return subscribeToLiveStructureShallowly(node, nodeCallback);
-      }
-    }
-    throw new Error(`"${first}" is not a valid event name`);
-  }
-  function getConnectionState() {
-    return state.connection.current.state;
-  }
   function connect() {
-    var _a2, _b, _c, _d;
-    if (state.connection.current.state !== "closed" && state.connection.current.state !== "unavailable") {
+    var _a2, _b;
+    if (context.connection.current.status !== "closed" && context.connection.current.status !== "unavailable") {
       return;
     }
     const auth = prepareAuthEndpoint(
       config.authentication,
-      (_b = (_a2 = config.polyfills) == null ? void 0 : _a2.fetch) != null ? _b : config.fetchPolyfill
+      (_a2 = config.polyfills) == null ? void 0 : _a2.fetch
     );
     const createWebSocket = prepareCreateWebSocket(
       config.liveblocksServer,
-      (_d = (_c = config.polyfills) == null ? void 0 : _c.WebSocket) != null ? _d : config.WebSocketPolyfill
+      (_b = config.polyfills) == null ? void 0 : _b.WebSocket
     );
-    updateConnection({ state: "authenticating" }, batchUpdates);
+    updateConnection({ status: "authenticating" }, batchUpdates);
     effects.authenticate(auth, createWebSocket);
   }
   function updatePresence(patch, options) {
     const oldValues = {};
-    if (state.buffer.me === null) {
-      state.buffer.me = {
+    if (context.buffer.me === null) {
+      context.buffer.me = {
         type: "partial",
         data: {}
       };
@@ -3380,18 +3640,18 @@ function makeStateMachine(state, config, mockedEffects) {
       if (overrideValue === void 0) {
         continue;
       }
-      state.buffer.me.data[key] = overrideValue;
-      oldValues[key] = state.me.current[key];
+      context.buffer.me.data[key] = overrideValue;
+      oldValues[key] = context.me.current[key];
     }
-    state.me.patch(patch);
-    if (state.activeBatch) {
+    context.me.patch(patch);
+    if (context.activeBatch) {
       if (options == null ? void 0 : options.addToHistory) {
-        state.activeBatch.reverseOps.unshift({
+        context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
         });
       }
-      state.activeBatch.updates.presence = true;
+      context.activeBatch.updates.presence = true;
     } else {
       tryFlushing();
       batchUpdates(() => {
@@ -3415,7 +3675,7 @@ function makeStateMachine(state, config, mockedEffects) {
     socket.addEventListener("error", onError);
     updateConnection(
       {
-        state: "connecting",
+        status: "connecting",
         id: token.actor,
         userInfo: token.info,
         userId: token.id,
@@ -3423,36 +3683,38 @@ function makeStateMachine(state, config, mockedEffects) {
       },
       batchUpdates
     );
-    state.idFactory = makeIdFactory(token.actor);
-    state.socket = socket;
+    context.idFactory = makeIdFactory(token.actor);
+    context.socket = socket;
   }
   function authenticationFailure(error2) {
     if (process.env.NODE_ENV !== "production") {
       error("Call to authentication endpoint failed", error2);
     }
-    state.token = null;
-    updateConnection({ state: "unavailable" }, batchUpdates);
-    state.numberOfRetry++;
-    state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
+    context.token = null;
+    updateConnection({ status: "unavailable" }, batchUpdates);
+    context.numberOfRetry++;
+    context.timeoutHandles.reconnect = effects.scheduleReconnect(
+      getRetryDelay()
+    );
   }
   function onVisibilityChange(visibilityState) {
-    if (visibilityState === "visible" && state.connection.current.state === "open") {
+    if (visibilityState === "visible" && context.connection.current.status === "open") {
       log("Heartbeat after visibility change");
       heartbeat();
     }
   }
   function onUpdatePresenceMessage(message) {
     if (message.targetActor !== void 0) {
-      const oldUser = state.others.getUser(message.actor);
-      state.others.setOther(message.actor, message.data);
-      const newUser = state.others.getUser(message.actor);
+      const oldUser = context.others.getUser(message.actor);
+      context.others.setOther(message.actor, message.data);
+      const newUser = context.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;
+      context.others.patchOther(message.actor, message.data), message;
     }
-    const user = state.others.getUser(message.actor);
+    const user = context.others.getUser(message.actor);
     if (user) {
       return {
         type: "update",
@@ -3464,24 +3726,24 @@ function makeStateMachine(state, config, mockedEffects) {
     }
   }
   function onUserLeftMessage(message) {
-    const user = state.others.getUser(message.actor);
+    const user = context.others.getUser(message.actor);
     if (user) {
-      state.others.removeConnection(message.actor);
+      context.others.removeConnection(message.actor);
       return { type: "leave", user };
     }
     return null;
   }
   function onRoomStateMessage(message) {
-    for (const connectionId in state.others._connections) {
+    for (const connectionId in context.others._connections) {
       const user = message.users[connectionId];
       if (user === void 0) {
-        state.others.removeConnection(Number(connectionId));
+        context.others.removeConnection(Number(connectionId));
       }
     }
     for (const key in message.users) {
       const user = message.users[key];
       const connectionId = Number(key);
-      state.others.setConnection(
+      context.others.setConnection(
         connectionId,
         user.id,
         user.info,
@@ -3491,7 +3753,7 @@ function makeStateMachine(state, config, mockedEffects) {
     return { type: "reset" };
   }
   function onNavigatorOnline() {
-    if (state.connection.current.state === "unavailable") {
+    if (context.connection.current.status === "unavailable") {
       log("Try to reconnect after connectivity change");
       reconnect();
     }
@@ -3502,19 +3764,19 @@ function makeStateMachine(state, config, mockedEffects) {
     });
   }
   function onUserJoinedMessage(message) {
-    state.others.setConnection(
+    context.others.setConnection(
       message.actor,
       message.id,
       message.info,
       isStorageReadOnly(message.scopes)
     );
-    state.buffer.messages.push({
+    context.buffer.messages.push({
       type: 100 /* UPDATE_PRESENCE */,
-      data: state.me.current,
+      data: context.me.current,
       targetActor: message.actor
     });
     tryFlushing();
-    const user = state.others.getUser(message.actor);
+    const user = context.others.getUser(message.actor);
     return user ? { type: "enter", user } : void 0;
   }
   function parseServerMessage(data) {
@@ -3535,7 +3797,7 @@ function makeStateMachine(state, config, mockedEffects) {
   }
   function onMessage(event) {
     if (event.data === "pong") {
-      clearTimeout(state.timeoutHandles.pongTimeout);
+      clearTimeout(context.timeoutHandles.pongTimeout);
       return;
     }
     const messages = parseServerMessages(event.data);
@@ -3583,7 +3845,7 @@ function makeStateMachine(state, config, mockedEffects) {
             break;
           }
           case 200 /* INITIAL_STORAGE_STATE */: {
-            const unacknowledgedOps = new Map(state.unacknowledgedOps);
+            const unacknowledgedOps = new Map(context.unacknowledgedOps);
             createOrUpdateRootFromMessage(message, doNotBatchUpdates);
             applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
             if (_getInitialStateResolver !== null) {
@@ -3598,10 +3860,7 @@ function makeStateMachine(state, config, mockedEffects) {
             applyResult.updates.storageUpdates.forEach((value, key) => {
               updates.storageUpdates.set(
                 key,
-                mergeStorageUpdates(
-                  updates.storageUpdates.get(key),
-                  value
-                )
+                mergeStorageUpdates(updates.storageUpdates.get(key), value)
               );
             });
             break;
@@ -3614,7 +3873,7 @@ function makeStateMachine(state, config, mockedEffects) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = (_a2 = state.opStackTraces) == null ? void 0 : _a2.get(opId);
+                const trace = (_a2 = context.opStackTraces) == null ? void 0 : _a2.get(opId);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -3639,90 +3898,95 @@ ${Array.from(traces).join("\n\n")}`
     });
   }
   function onClose(event) {
-    state.socket = null;
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    clearInterval(state.intervalHandles.heartbeat);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    state.others.clearOthers();
+    context.socket = null;
+    clearTimeout(context.timeoutHandles.pongTimeout);
+    clearInterval(context.intervalHandles.heartbeat);
+    if (context.timeoutHandles.flush) {
+      clearTimeout(context.timeoutHandles.flush);
+    }
+    clearTimeout(context.timeoutHandles.reconnect);
+    context.others.clearOthers();
     batchUpdates(() => {
       notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
       if (event.code >= 4e3 && event.code <= 4100) {
-        updateConnection({ state: "failed" }, doNotBatchUpdates);
+        updateConnection({ status: "failed" }, doNotBatchUpdates);
         const error2 = new LiveblocksError(event.reason, event.code);
         eventHub.error.notify(error2);
         const delay = getRetryDelay(true);
-        state.numberOfRetry++;
+        context.numberOfRetry++;
         if (process.env.NODE_ENV !== "production") {
           error(
             `Connection to websocket server closed. Reason: ${error2.message} (code: ${error2.code}). Retrying in ${delay}ms.`
           );
         }
-        updateConnection({ state: "unavailable" }, doNotBatchUpdates);
-        state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+        updateConnection({ status: "unavailable" }, doNotBatchUpdates);
+        context.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
       } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */) {
-        updateConnection({ state: "closed" }, doNotBatchUpdates);
+        updateConnection({ status: "closed" }, doNotBatchUpdates);
       } else {
         const delay = getRetryDelay();
-        state.numberOfRetry++;
+        context.numberOfRetry++;
         if (process.env.NODE_ENV !== "production") {
           warn(
             `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`
           );
         }
-        updateConnection({ state: "unavailable" }, doNotBatchUpdates);
-        state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+        updateConnection({ status: "unavailable" }, doNotBatchUpdates);
+        context.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
       }
     });
   }
   function updateConnection(connection, batchedUpdatesWrapper) {
-    state.connection.set(connection);
+    context.connection.set(connection);
     batchedUpdatesWrapper(() => {
-      eventHub.connection.notify(connection.state);
+      eventHub.connection.notify(connection.status);
     });
   }
   function getRetryDelay(slow = false) {
     if (slow) {
-      return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
+      return BACKOFF_RETRY_DELAYS_SLOW[context.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? context.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
     }
-    return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
+    return BACKOFF_RETRY_DELAYS[context.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? context.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
   }
   function onError() {
   }
   function onOpen() {
-    clearInterval(state.intervalHandles.heartbeat);
-    state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
-    if (state.connection.current.state === "connecting") {
+    clearInterval(context.intervalHandles.heartbeat);
+    context.intervalHandles.heartbeat = effects.startHeartbeatInterval();
+    if (context.connection.current.status === "connecting") {
       updateConnection(
-        __spreadProps(__spreadValues({}, state.connection.current), { state: "open" }),
+        __spreadProps(__spreadValues({}, context.connection.current), { status: "open" }),
         batchUpdates
       );
-      state.numberOfRetry = 0;
-      if (state.lastConnectionId !== void 0) {
-        state.buffer.me = {
+      context.numberOfRetry = 0;
+      if (context.lastConnectionId !== void 0) {
+        context.buffer.me = {
           type: "full",
-          data: __spreadValues({}, state.me.current)
+          data: (
+            // Because state.me.current is a readonly object, we'll have to
+            // make a copy here. Otherwise, type errors happen later when
+            // "patching" my presence.
+            __spreadValues({}, context.me.current)
+          )
         };
         tryFlushing();
       }
-      state.lastConnectionId = state.connection.current.id;
-      if (state.root) {
-        state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      context.lastConnectionId = context.connection.current.id;
+      if (context.root) {
+        context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
       }
       tryFlushing();
     } else {
     }
   }
   function heartbeat() {
-    if (state.socket === null) {
+    if (context.socket === null) {
       return;
     }
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-    if (state.socket.readyState === state.socket.OPEN) {
-      state.socket.send("ping");
+    clearTimeout(context.timeoutHandles.pongTimeout);
+    context.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
+    if (context.socket.readyState === context.socket.OPEN) {
+      context.socket.send("ping");
     }
   }
   function pongTimeout() {
@@ -3730,21 +3994,21 @@ ${Array.from(traces).join("\n\n")}`
     reconnect();
   }
   function reconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
-    }
-    updateConnection({ state: "unavailable" }, batchUpdates);
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    clearInterval(state.intervalHandles.heartbeat);
+    if (context.socket) {
+      context.socket.removeEventListener("open", onOpen);
+      context.socket.removeEventListener("message", onMessage);
+      context.socket.removeEventListener("close", onClose);
+      context.socket.removeEventListener("error", onError);
+      context.socket.close();
+      context.socket = null;
+    }
+    updateConnection({ status: "unavailable" }, batchUpdates);
+    clearTimeout(context.timeoutHandles.pongTimeout);
+    if (context.timeoutHandles.flush) {
+      clearTimeout(context.timeoutHandles.flush);
+    }
+    clearTimeout(context.timeoutHandles.reconnect);
+    clearInterval(context.intervalHandles.heartbeat);
     connect();
   }
   function applyAndSendOps(offlineOps, batchedUpdatesWrapper) {
@@ -3762,114 +4026,111 @@ ${Array.from(traces).join("\n\n")}`
     effects.send(messages);
   }
   function tryFlushing() {
-    const storageOps = state.buffer.storageOperations;
+    const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
       storageOps.forEach((op) => {
-        state.unacknowledgedOps.set(nn(op.opId), op);
+        context.unacknowledgedOps.set(nn(op.opId), op);
       });
       notifyStorageStatus();
     }
-    if (state.socket === null || state.socket.readyState !== state.socket.OPEN) {
-      state.buffer.storageOperations = [];
+    if (context.socket === null || context.socket.readyState !== context.socket.OPEN) {
+      context.buffer.storageOperations = [];
       return;
     }
     const now = Date.now();
-    const elapsedTime = now - state.lastFlushTime;
+    const elapsedTime = now - context.lastFlushTime;
     if (elapsedTime > config.throttleDelay) {
-      const messages = flushDataToMessages(state);
+      const messages = flushDataToMessages(context);
       if (messages.length === 0) {
         return;
       }
       effects.send(messages);
-      state.buffer = {
+      context.buffer = {
         messages: [],
         storageOperations: [],
         me: null
       };
-      state.lastFlushTime = now;
+      context.lastFlushTime = now;
     } else {
-      if (state.timeoutHandles.flush !== null) {
-        clearTimeout(state.timeoutHandles.flush);
+      if (context.timeoutHandles.flush !== null) {
+        clearTimeout(context.timeoutHandles.flush);
       }
-      state.timeoutHandles.flush = effects.delayFlush(
-        config.throttleDelay - (now - state.lastFlushTime)
+      context.timeoutHandles.flush = effects.delayFlush(
+        config.throttleDelay - (now - context.lastFlushTime)
       );
     }
   }
-  function flushDataToMessages(state2) {
+  function flushDataToMessages(state) {
     const messages = [];
-    if (state2.buffer.me) {
+    if (state.buffer.me) {
       messages.push(
-        state2.buffer.me.type === "full" ? {
+        state.buffer.me.type === "full" ? {
           type: 100 /* UPDATE_PRESENCE */,
+          // Populating the `targetActor` field turns this message into
+          // a Full Presence™ update message (not a patch), which will get
+          // interpreted by other clients as such.
           targetActor: -1,
-          data: state2.buffer.me.data
+          data: state.buffer.me.data
         } : {
           type: 100 /* UPDATE_PRESENCE */,
-          data: state2.buffer.me.data
+          data: state.buffer.me.data
         }
       );
     }
-    for (const event of state2.buffer.messages) {
+    for (const event of state.buffer.messages) {
       messages.push(event);
     }
-    if (state2.buffer.storageOperations.length > 0) {
+    if (state.buffer.storageOperations.length > 0) {
       messages.push({
         type: 201 /* UPDATE_STORAGE */,
-        ops: state2.buffer.storageOperations
+        ops: state.buffer.storageOperations
       });
     }
     return messages;
   }
   function disconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
+    if (context.socket) {
+      context.socket.removeEventListener("open", onOpen);
+      context.socket.removeEventListener("message", onMessage);
+      context.socket.removeEventListener("close", onClose);
+      context.socket.removeEventListener("error", onError);
+      context.socket.close();
+      context.socket = null;
     }
     batchUpdates(() => {
-      updateConnection({ state: "closed" }, doNotBatchUpdates);
-      if (state.timeoutHandles.flush) {
-        clearTimeout(state.timeoutHandles.flush);
+      updateConnection({ status: "closed" }, doNotBatchUpdates);
+      if (context.timeoutHandles.flush) {
+        clearTimeout(context.timeoutHandles.flush);
       }
-      clearTimeout(state.timeoutHandles.reconnect);
-      clearTimeout(state.timeoutHandles.pongTimeout);
-      clearInterval(state.intervalHandles.heartbeat);
-      state.others.clearOthers();
+      clearTimeout(context.timeoutHandles.reconnect);
+      clearTimeout(context.timeoutHandles.pongTimeout);
+      clearInterval(context.intervalHandles.heartbeat);
+      context.others.clearOthers();
       notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
       Object.values(eventHub).forEach((eventSource2) => eventSource2.clear());
     });
   }
-  function getPresence() {
-    return state.me.current;
-  }
-  function getOthers() {
-    return state.others.current;
-  }
   function broadcastEvent(event, options = {
     shouldQueueEventIfNotReady: false
   }) {
-    if (state.socket === null && !options.shouldQueueEventIfNotReady) {
+    if (context.socket === null && !options.shouldQueueEventIfNotReady) {
       return;
     }
-    state.buffer.messages.push({
+    context.buffer.messages.push({
       type: 103 /* BROADCAST_EVENT */,
       event
     });
     tryFlushing();
   }
   function dispatchOps(ops) {
-    state.buffer.storageOperations.push(...ops);
+    context.buffer.storageOperations.push(...ops);
     tryFlushing();
   }
   let _getInitialStatePromise = null;
   let _getInitialStateResolver = null;
   function startLoadingStorage() {
     if (_getInitialStatePromise === null) {
-      state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
       tryFlushing();
       _getInitialStatePromise = new Promise(
         (resolve) => _getInitialStateResolver = resolve
@@ -3879,7 +4140,7 @@ ${Array.from(traces).join("\n\n")}`
     return _getInitialStatePromise;
   }
   function getStorageSnapshot() {
-    const root = state.root;
+    const root = context.root;
     if (root !== void 0) {
       return root;
     } else {
@@ -3889,74 +4150,74 @@ ${Array.from(traces).join("\n\n")}`
   }
   function getStorage() {
     return __async(this, null, function* () {
-      if (state.root) {
+      if (context.root) {
         return Promise.resolve({
-          root: state.root
+          root: context.root
         });
       }
       yield startLoadingStorage();
       return {
-        root: nn(state.root)
+        root: nn(context.root)
       };
     });
   }
   function undo() {
-    if (state.activeBatch) {
+    if (context.activeBatch) {
       throw new Error("undo is not allowed during a batch");
     }
-    const historyOps = state.undoStack.pop();
+    const historyOps = context.undoStack.pop();
     if (historyOps === void 0) {
       return;
     }
-    state.pausedHistory = null;
+    context.pausedHistory = null;
     const result = applyOps(historyOps, true);
     batchUpdates(() => {
       notify(result.updates, doNotBatchUpdates);
-      state.redoStack.push(result.reverse);
+      context.redoStack.push(result.reverse);
       onHistoryChange(doNotBatchUpdates);
     });
     for (const op of result.ops) {
       if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
+        context.buffer.storageOperations.push(op);
       }
     }
     tryFlushing();
   }
   function canUndo() {
-    return state.undoStack.length > 0;
+    return context.undoStack.length > 0;
   }
   function redo() {
-    if (state.activeBatch) {
+    if (context.activeBatch) {
       throw new Error("redo is not allowed during a batch");
     }
-    const historyOps = state.redoStack.pop();
+    const historyOps = context.redoStack.pop();
     if (historyOps === void 0) {
       return;
     }
-    state.pausedHistory = null;
+    context.pausedHistory = null;
     const result = applyOps(historyOps, true);
     batchUpdates(() => {
       notify(result.updates, doNotBatchUpdates);
-      state.undoStack.push(result.reverse);
+      context.undoStack.push(result.reverse);
       onHistoryChange(doNotBatchUpdates);
     });
     for (const op of result.ops) {
       if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
+        context.buffer.storageOperations.push(op);
       }
     }
     tryFlushing();
   }
   function canRedo() {
-    return state.redoStack.length > 0;
+    return context.redoStack.length > 0;
   }
   function batch(callback) {
-    if (state.activeBatch) {
+    if (context.activeBatch) {
       return callback();
     }
     let returnValue = void 0;
     batchUpdates(() => {
-      state.activeBatch = {
+      context.activeBatch = {
         ops: [],
         updates: {
           storageUpdates: /* @__PURE__ */ new Map(),
@@ -3968,13 +4229,13 @@ ${Array.from(traces).join("\n\n")}`
       try {
         returnValue = callback();
       } finally {
-        const currentBatch = state.activeBatch;
-        state.activeBatch = null;
+        const currentBatch = context.activeBatch;
+        context.activeBatch = null;
         if (currentBatch.reverseOps.length > 0) {
           addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
         }
         if (currentBatch.ops.length > 0) {
-          state.redoStack = [];
+          context.redoStack = [];
         }
         if (currentBatch.ops.length > 0) {
           dispatchOps(currentBatch.ops);
@@ -3986,18 +4247,18 @@ ${Array.from(traces).join("\n\n")}`
     return returnValue;
   }
   function pauseHistory() {
-    state.pausedHistory = [];
+    context.pausedHistory = [];
   }
   function resumeHistory() {
-    const historyOps = state.pausedHistory;
-    state.pausedHistory = null;
+    const historyOps = context.pausedHistory;
+    context.pausedHistory = null;
     if (historyOps !== null && historyOps.length > 0) {
       _addToRealUndoStack(historyOps, batchUpdates);
     }
   }
   function simulateSocketClose() {
-    if (state.socket) {
-      state.socket = null;
+    if (context.socket) {
+      context.socket = null;
     }
   }
   function simulateSendCloseEvent(event) {
@@ -4007,10 +4268,10 @@ ${Array.from(traces).join("\n\n")}`
     if (_getInitialStatePromise === null) {
       return "not-loaded";
     }
-    if (state.root === void 0) {
+    if (context.root === void 0) {
       return "loading";
     }
-    return state.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
+    return context.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
   }
   let _lastStorageStatus = getStorageStatus();
   function notifyStorageStatus() {
@@ -4020,23 +4281,34 @@ ${Array.from(traces).join("\n\n")}`
       eventHub.storageStatus.notify(storageStatus);
     }
   }
+  const others_forDevTools = new DerivedRef(
+    context.others,
+    (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
+  );
   return {
+    // Internal
+    get state() {
+      return context;
+    },
     onClose,
     onMessage,
     authenticationSuccess,
     heartbeat,
     onNavigatorOnline,
+    // Internal DevTools
     simulateSocketClose,
     simulateSendCloseEvent,
     onVisibilityChange,
-    getUndoStack: () => state.undoStack,
-    getItemsCount: () => state.nodes.size,
+    getUndoStack: () => context.undoStack,
+    getItemsCount: () => context.nodes.size,
+    // Core
     connect,
     disconnect,
     reconnect,
-    subscribe,
+    // Presence
     updatePresence,
     broadcastEvent,
+    // Storage
     batch,
     undo,
     redo,
@@ -4058,83 +4330,45 @@ ${Array.from(traces).join("\n\n")}`
       storageDidLoad: eventHub.storageDidLoad.observable,
       storageStatus: eventHub.storageStatus.observable
     },
-    getConnectionState,
-    isSelfAware: () => isConnectionSelfAware(state.connection.current),
+    // Core
+    getConnectionState: () => context.connection.current.status,
+    isSelfAware: () => isConnectionSelfAware(context.connection.current),
     getSelf: () => self.current,
-    getPresence,
-    getOthers,
+    // Presence
+    getPresence: () => context.me.current,
+    getOthers: () => context.others.current,
+    // Support for the Liveblocks browser extension
     getSelf_forDevTools: () => selfAsTreeNode.current,
-    getOthers_forDevTools: () => state.others_forDevTools.current
-  };
-}
-function defaultState(initialPresence, initialStorage) {
-  const others = new OthersRef();
-  const others_forDevTools = new DerivedRef(
-    others,
-    (others2) => others2.map((other, index) => userToTreeNode(`Other ${index}`, other))
-  );
-  const connection = new ValueRef({ state: "closed" });
-  return {
-    token: null,
-    lastConnectionId: null,
-    socket: null,
-    numberOfRetry: 0,
-    lastFlushTime: 0,
-    timeoutHandles: {
-      flush: null,
-      reconnect: 0,
-      pongTimeout: 0
-    },
-    buffer: {
-      me: {
-        type: "full",
-        data: initialPresence
-      },
-      messages: [],
-      storageOperations: []
-    },
-    intervalHandles: {
-      heartbeat: 0
-    },
-    connection,
-    me: new MeRef(initialPresence),
-    others,
-    others_forDevTools,
-    initialStorage,
-    idFactory: null,
-    clock: 0,
-    opClock: 0,
-    nodes: /* @__PURE__ */ new Map(),
-    root: void 0,
-    undoStack: [],
-    redoStack: [],
-    pausedHistory: null,
-    activeBatch: null,
-    unacknowledgedOps: /* @__PURE__ */ new Map(),
-    opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
+    getOthers_forDevTools: () => others_forDevTools.current
   };
 }
 function createRoom(options, config) {
   const { initialPresence, initialStorage } = options;
-  const state = defaultState(
+  const machine = makeStateMachine(
+    config,
     typeof initialPresence === "function" ? initialPresence(config.roomId) : initialPresence,
     typeof initialStorage === "function" ? initialStorage(config.roomId) : initialStorage
   );
-  const machine = makeStateMachine(
-    state,
-    config
-  );
   const room = {
     id: config.roomId,
+    /////////////
+    // Core    //
+    /////////////
     getConnectionState: machine.getConnectionState,
     isSelfAware: machine.isSelfAware,
     getSelf: machine.getSelf,
     reconnect: machine.reconnect,
-    subscribe: machine.subscribe,
+    subscribe: makeClassicSubscribeFn(machine),
+    //////////////
+    // Presence //
+    //////////////
     getPresence: machine.getPresence,
     updatePresence: machine.updatePresence,
     getOthers: machine.getOthers,
     broadcastEvent: machine.broadcastEvent,
+    //////////////
+    // Storage  //
+    //////////////
     getStorage: machine.getStorage,
     getStorageSnapshot: machine.getStorageSnapshot,
     getStorageStatus: machine.getStorageStatus,
@@ -4148,20 +4382,104 @@ function createRoom(options, config) {
       pause: machine.pauseHistory,
       resume: machine.resumeHistory
     },
-    __INTERNAL_DO_NOT_USE: {
+    __internal: {
+      connect: machine.connect,
+      disconnect: machine.disconnect,
+      onNavigatorOnline: machine.onNavigatorOnline,
+      onVisibilityChange: machine.onVisibilityChange,
       simulateCloseWebsocket: machine.simulateSocketClose,
-      simulateSendCloseEvent: machine.simulateSendCloseEvent
-    },
-    getSelf_forDevTools: machine.getSelf_forDevTools,
-    getOthers_forDevTools: machine.getOthers_forDevTools
-  };
-  return {
-    connect: machine.connect,
-    disconnect: machine.disconnect,
-    onNavigatorOnline: machine.onNavigatorOnline,
-    onVisibilityChange: machine.onVisibilityChange,
-    room
+      simulateSendCloseEvent: machine.simulateSendCloseEvent,
+      getSelf_forDevTools: machine.getSelf_forDevTools,
+      getOthers_forDevTools: machine.getOthers_forDevTools
+    }
   };
+  return room;
+}
+function makeClassicSubscribeFn(machine) {
+  function subscribeToLiveStructureDeeply(node, callback) {
+    return machine.events.storage.subscribe((updates) => {
+      const relatedUpdates = updates.filter(
+        (update) => isSameNodeOrChildOf(update.node, node)
+      );
+      if (relatedUpdates.length > 0) {
+        callback(relatedUpdates);
+      }
+    });
+  }
+  function subscribeToLiveStructureShallowly(node, callback) {
+    return machine.events.storage.subscribe((updates) => {
+      for (const update of updates) {
+        if (update.node._id === node._id) {
+          callback(update.node);
+        }
+      }
+    });
+  }
+  function subscribe(first, second, options) {
+    if (typeof first === "string" && isRoomEventName(first)) {
+      if (typeof second !== "function") {
+        throw new Error("Second argument must be a callback function");
+      }
+      const callback = second;
+      switch (first) {
+        case "event":
+          return machine.events.customEvent.subscribe(
+            callback
+          );
+        case "my-presence":
+          return machine.events.me.subscribe(callback);
+        case "others": {
+          const cb = callback;
+          return machine.events.others.subscribe(
+            ({ others, event }) => cb(others, event)
+          );
+        }
+        case "error":
+          return machine.events.error.subscribe(callback);
+        case "connection":
+          return machine.events.connection.subscribe(
+            callback
+          );
+        case "storage":
+          return machine.events.storage.subscribe(
+            callback
+          );
+        case "history":
+          return machine.events.history.subscribe(
+            callback
+          );
+        case "storage-status":
+          return machine.events.storageStatus.subscribe(
+            callback
+          );
+        default:
+          return assertNever(first, "Unknown event");
+      }
+    }
+    if (second === void 0 || typeof first === "function") {
+      if (typeof first === "function") {
+        const storageCallback = first;
+        return machine.events.storage.subscribe(storageCallback);
+      } else {
+        throw new Error("Please specify a listener callback");
+      }
+    }
+    if (isLiveNode(first)) {
+      const node = first;
+      if (options == null ? void 0 : options.isDeep) {
+        const storageCallback = second;
+        return subscribeToLiveStructureDeeply(node, storageCallback);
+      } else {
+        const nodeCallback = second;
+        return subscribeToLiveStructureShallowly(node, nodeCallback);
+      }
+    }
+    throw new Error(`"${first}" is not a valid event name`);
+  }
+  return subscribe;
+}
+function isRoomEventName(value) {
+  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history" || value === "storage-status";
 }
 var LiveblocksError = class extends Error {
   constructor(message, code) {
@@ -4178,7 +4496,13 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
   const ws = WebSocketPolyfill || WebSocket;
   return (token) => {
     return new ws(
-      `${liveblocksServer}/?token=${token}&version=${true ? "1.0.2" : "dev"}`
+      `${liveblocksServer}/?token=${token}&version=${// prettier-ignore
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore (__PACKAGE_VERSION__ will be injected by the build script)
+      true ? (
+        /* istanbul ignore next */
+        "1.0.6-test2"
+      ) : "dev"}`
     );
   };
 }
@@ -4190,7 +4514,8 @@ function prepareAuthEndpoint(authentication, fetchPolyfill) {
       );
     }
     return (room) => fetchAuthEndpoint(
-      fetchPolyfill || fetch,
+      fetchPolyfill || /* istanbul ignore next */
+      fetch,
       authentication.url,
       {
         room,
@@ -4228,6 +4553,7 @@ function fetchAuthEndpoint(fetch2, endpoint, body) {
       headers: {
         "Content-Type": "application/json"
       },
+      // Credentials are needed to support authentication with cookies
       credentials: "include",
       body: JSON.stringify(body)
     });
@@ -4267,24 +4593,23 @@ var MAX_THROTTLE = 1e3;
 var DEFAULT_THROTTLE = 100;
 function createClient(options) {
   const clientOptions = options;
-  const throttleDelay = getThrottleDelayFromOptions(options);
+  const throttleDelay = getThrottleDelayFromOptions(clientOptions);
   const rooms = /* @__PURE__ */ new Map();
   function getRoom(roomId) {
-    const internalRoom = rooms.get(roomId);
-    return internalRoom ? internalRoom.room : null;
+    const room = rooms.get(roomId);
+    return room ? room : null;
   }
   function enter(roomId, options2) {
-    var _a, _b;
-    const shouldConnect = options2.shouldInitiallyConnect === void 0 ? true : options2.shouldInitiallyConnect;
-    let internalRoom = rooms.get(roomId);
-    if (internalRoom) {
-      return internalRoom.room;
+    var _a, _b, _c;
+    const existingRoom = rooms.get(roomId);
+    if (existingRoom !== void 0) {
+      return existingRoom;
     }
     deprecateIf(
       options2.initialPresence === null || options2.initialPresence === void 0,
       "Please provide an initial presence value for the current user when entering the room."
     );
-    internalRoom = createRoom(
+    const newRoom = createRoom(
       {
         initialPresence: (_a = options2.initialPresence) != null ? _a : {},
         initialStorage: options2.initialStorage
@@ -4293,51 +4618,52 @@ function createClient(options) {
         roomId,
         throttleDelay,
         polyfills: clientOptions.polyfills,
-        WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-        fetchPolyfill: clientOptions.fetchPolyfill,
         unstable_batchedUpdates: options2 == null ? void 0 : options2.unstable_batchedUpdates,
-        liveblocksServer: (clientOptions == null ? void 0 : clientOptions.liveblocksServer) || "wss://api.liveblocks.io/v6",
+        liveblocksServer: (
+          // TODO Patch this using public but marked internal fields?
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (clientOptions == null ? void 0 : clientOptions.liveblocksServer) || "wss://api.liveblocks.io/v6"
+        ),
         authentication: prepareAuthentication(clientOptions, roomId)
       }
     );
-    rooms.set(
-      roomId,
-      internalRoom
-    );
+    rooms.set(roomId, newRoom);
     setupDevTools(() => Array.from(rooms.keys()));
-    linkDevTools(roomId, internalRoom.room);
+    linkDevTools(roomId, newRoom);
+    const shouldConnect = (_b = options2.shouldInitiallyConnect) != null ? _b : true;
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (((_b = clientOptions.polyfills) == null ? void 0 : _b.atob) === void 0) {
+        if (((_c = clientOptions.polyfills) == null ? void 0 : _c.atob) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
         }
         global.atob = clientOptions.polyfills.atob;
       }
-      internalRoom.connect();
+      newRoom.__internal.connect();
     }
-    return internalRoom.room;
+    return newRoom;
   }
   function leave(roomId) {
     unlinkDevTools(roomId);
     const room = rooms.get(roomId);
-    if (room) {
-      room.disconnect();
+    if (room !== void 0) {
+      room.__internal.disconnect();
       rooms.delete(roomId);
     }
   }
-  if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+  if (typeof window !== "undefined" && // istanbul ignore next: React Native environment doesn't implement window.addEventListener
+  typeof window.addEventListener !== "undefined") {
     window.addEventListener("online", () => {
       for (const [, room] of rooms) {
-        room.onNavigatorOnline();
+        room.__internal.onNavigatorOnline();
       }
     });
   }
   if (typeof document !== "undefined") {
     document.addEventListener("visibilitychange", () => {
       for (const [, room] of rooms) {
-        room.onVisibilityChange(document.visibilityState);
+        room.__internal.onVisibilityChange(document.visibilityState);
       }
     });
   }