@liveblocks/core 3.14.0-pre3 → 3.14.0-pre5

package/dist/index.cjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.14.0-pre3";
+var PKG_VERSION = "3.14.0-pre5";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -567,6 +567,9 @@ var SortedList = class _SortedList {
     this.#lt = lt;
     this.#data = alreadySortedList;
   }
+  /**
+   * Creates an empty SortedList with the given "less than" function.
+   */
   static with(lt) {
     return _SortedList.fromAlreadySorted([], lt);
   }
@@ -588,10 +591,12 @@ var SortedList = class _SortedList {
   }
   /**
    * Adds a new item to the sorted list, such that it remains sorted.
+   * Returns the index where the item was inserted.
    */
   add(value) {
     const idx = bisectRight(this.#data, value, this.#lt);
     this.#data.splice(idx, 0, value);
+    return idx;
   }
   /**
    * Removes all values from the sorted list, making it empty again.
@@ -636,6 +641,60 @@ var SortedList = class _SortedList {
     }
     return false;
   }
+  /**
+   * Removes the item at the given index.
+   * Returns the removed item, or undefined if index is out of bounds.
+   */
+  removeAt(index) {
+    if (index < 0 || index >= this.#data.length) {
+      return void 0;
+    }
+    const [removed] = this.#data.splice(index, 1);
+    return removed;
+  }
+  /**
+   * Repositions an item to maintain sorted order after its sort key has
+   * been mutated in-place. For example:
+   *
+   *   const item = sorted.at(3);
+   *   item.updatedAt = new Date();  // mutate the item's sort key in-place
+   *   sorted.reposition(item);      // restore sorted order
+   *
+   * Returns the new index of the item. Throws if the item is not in the list.
+   *
+   * Semantically equivalent to remove(value) + add(value), but optimized
+   * to avoid array shifting when the item only moves a short distance.
+   */
+  reposition(value) {
+    const oldIdx = this.#data.indexOf(value);
+    if (oldIdx < 0) {
+      throw new Error("Cannot reposition item that is not in the list");
+    }
+    const prev = this.#data[oldIdx - 1];
+    const next = this.#data[oldIdx + 1];
+    const validLeft = prev === void 0 || this.#lt(prev, value);
+    const validRight = next === void 0 || this.#lt(value, next);
+    if (validLeft && validRight) {
+      return oldIdx;
+    }
+    let newIdx = oldIdx;
+    while (newIdx > 0 && this.#lt(value, this.#data[newIdx - 1])) {
+      this.#data[newIdx] = this.#data[newIdx - 1];
+      newIdx--;
+    }
+    if (newIdx < oldIdx) {
+      this.#data[newIdx] = value;
+      return newIdx;
+    }
+    while (newIdx < this.#data.length - 1 && !this.#lt(value, this.#data[newIdx + 1])) {
+      this.#data[newIdx] = this.#data[newIdx + 1];
+      newIdx++;
+    }
+    if (newIdx !== oldIdx) {
+      this.#data[newIdx] = value;
+    }
+    return newIdx;
+  }
   at(index) {
     return this.#data[index];
   }
@@ -5898,16 +5957,68 @@ function before(pos) {
   }
   return ONE;
 }
+var VIEWPORT_START = 2;
+var VIEWPORT_STEP = 3;
 function after(pos) {
-  for (let i = 0; i <= pos.length - 1; i++) {
+  for (let i = 0; i < pos.length; i++) {
     const code = pos.charCodeAt(i);
-    if (code >= MAX_CODE) {
-      continue;
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return pos + ONE;
     }
-    return pos.substring(0, i) + String.fromCharCode(code + 1);
+  }
+  while (pos.length > 1 && pos.charCodeAt(pos.length - 1) === MIN_CODE) {
+    pos = pos.slice(0, -1);
+  }
+  if (pos.length === 0 || pos === ZERO) {
+    return ONE;
+  }
+  let viewport = VIEWPORT_START;
+  if (pos.length > VIEWPORT_START) {
+    viewport = VIEWPORT_START + Math.ceil((pos.length - VIEWPORT_START) / VIEWPORT_STEP) * VIEWPORT_STEP;
+  }
+  const result = incrementWithinViewport(pos, viewport);
+  if (result !== null) {
+    return result;
+  }
+  viewport += VIEWPORT_STEP;
+  const extendedResult = incrementWithinViewport(pos, viewport);
+  if (extendedResult !== null) {
+    return extendedResult;
   }
   return pos + ONE;
 }
+function incrementWithinViewport(pos, viewport) {
+  const digits = [];
+  for (let i = 0; i < viewport; i++) {
+    if (i < pos.length) {
+      digits.push(pos.charCodeAt(i) - MIN_CODE);
+    } else {
+      digits.push(0);
+    }
+  }
+  let carry = 1;
+  for (let i = viewport - 1; i >= 0 && carry; i--) {
+    const sum = digits[i] + carry;
+    if (sum >= NUM_DIGITS) {
+      digits[i] = 0;
+      carry = 1;
+    } else {
+      digits[i] = sum;
+      carry = 0;
+    }
+  }
+  if (carry) {
+    return null;
+  }
+  let result = "";
+  for (const d of digits) {
+    result += String.fromCharCode(d + MIN_CODE);
+  }
+  while (result.length > 1 && result.charCodeAt(result.length - 1) === MIN_CODE) {
+    result = result.slice(0, -1);
+  }
+  return result;
+}
 function between(lo, hi) {
   if (lo < hi) {
     return _between(lo, hi);
@@ -6368,29 +6479,27 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
 };
 
 // src/crdts/LiveList.ts
-function compareNodePosition(itemA, itemB) {
-  const posA = itemA._parentPos;
-  const posB = itemB._parentPos;
-  return posA === posB ? 0 : posA < posB ? -1 : 1;
+function childNodeLt(a, b) {
+  return a._parentPos < b._parentPos;
 }
 var LiveList = class _LiveList extends AbstractCrdt {
-  // TODO: Naive array at first, find a better data structure. Maybe an Order statistics tree?
   #items;
   #implicitlyDeletedItems;
   #unacknowledgedSets;
   constructor(items) {
     super();
-    this.#items = [];
     this.#implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
     this.#unacknowledgedSets = /* @__PURE__ */ new Map();
-    let position = void 0;
+    const nodes = [];
+    let lastPos;
     for (const item of items) {
-      const newPosition = makePosition(position);
+      const pos = makePosition(lastPos);
       const node = lsonToLiveNode(item);
-      node._setParentLink(this, newPosition);
-      this.#items.push(node);
-      position = newPosition;
+      node._setParentLink(this, pos);
+      nodes.push(node);
+      lastPos = pos;
     }
+    this.#items = SortedList.fromAlreadySorted(nodes, childNodeLt);
   }
   /** @internal */
   static _deserialize([id, _], parentToChildren, pool) {
@@ -6404,7 +6513,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       const crdt = node[1];
       const child = deserialize(node, parentToChildren, pool);
       child._setParentLink(list, crdt.parentKey);
-      list._insertAndSort(child);
+      list.#insert(child);
     }
     return list;
   }
@@ -6440,19 +6549,33 @@ var LiveList = class _LiveList extends AbstractCrdt {
     return ops;
   }
   /**
-   * @internal
-   *
-   * Adds a new item into the sorted list, in the correct position.
+   * Inserts a new child into the list in the correct location (binary search
+   * finds correct position efficiently). Returns the insertion index.
    */
-  _insertAndSort(item) {
-    this.#items.push(item);
-    this._sortItems();
+  #insert(childNode) {
+    const index = this.#items.add(childNode);
+    this.invalidate();
+    return index;
   }
-  /** @internal */
-  _sortItems() {
-    this.#items.sort(compareNodePosition);
+  /**
+   * Updates an item's position and repositions it in the sorted list.
+   * Encapsulates the remove -> mutate -> add cycle needed when changing sort keys.
+   *
+   * IMPORTANT: Item must exist in this list. List count remains unchanged.
+   */
+  #updateItemPosition(item, newKey) {
+    item._setParentLink(this, newKey);
+    this.#items.reposition(item);
     this.invalidate();
   }
+  /**
+   * Updates an item's position by index. Safer than #updateItemPosition when you have
+   * an index, as it ensures the item exists and is from this list.
+   */
+  #updateItemPositionAt(index, newKey) {
+    const item = nn(this.#items.at(index));
+    this.#updateItemPosition(item, newKey);
+  }
   /** @internal */
   _indexOfPosition(position) {
     return this.#items.findIndex(
@@ -6484,10 +6607,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const deletedId = op.deletedId;
     const indexOfItemWithSamePosition = this._indexOfPosition(key);
     if (indexOfItemWithSamePosition !== -1) {
-      const itemWithSamePosition = this.#items[indexOfItemWithSamePosition];
+      const itemWithSamePosition = nn(
+        this.#items.removeAt(indexOfItemWithSamePosition)
+      );
       if (itemWithSamePosition._id === deletedId) {
         itemWithSamePosition._detach();
-        this.#items[indexOfItemWithSamePosition] = child;
+        this.#items.add(child);
         return {
           modified: makeUpdate(this, [
             setDelta(indexOfItemWithSamePosition, child)
@@ -6496,7 +6621,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       } else {
         this.#implicitlyDeletedItems.add(itemWithSamePosition);
-        this.#items[indexOfItemWithSamePosition] = child;
+        this.#items.remove(itemWithSamePosition);
+        this.#items.add(child);
         const delta = [
           setDelta(indexOfItemWithSamePosition, child)
         ];
@@ -6519,7 +6645,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (deleteDelta2) {
         updates.push(deleteDelta2);
       }
-      this._insertAndSort(child);
+      this.#insert(child);
       updates.push(insertDelta(this._indexOfPosition(key), child));
       return {
         reverse: [],
@@ -6554,16 +6680,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       }
       if (indexOfItemWithSamePosition !== -1) {
-        this.#implicitlyDeletedItems.add(
-          this.#items[indexOfItemWithSamePosition]
+        const itemAtPosition = nn(
+          this.#items.removeAt(indexOfItemWithSamePosition)
         );
-        const [prevNode] = this.#items.splice(indexOfItemWithSamePosition, 1);
-        delta.push(deleteDelta(indexOfItemWithSamePosition, prevNode));
+        this.#implicitlyDeletedItems.add(itemAtPosition);
+        delta.push(deleteDelta(indexOfItemWithSamePosition, itemAtPosition));
       }
-      const prevIndex = this.#items.indexOf(existingItem);
-      existingItem._setParentLink(this, op.parentKey);
-      this._sortItems();
-      const newIndex = this.#items.indexOf(existingItem);
+      const prevIndex = this.#items.findIndex((item) => item === existingItem);
+      this.#updateItemPosition(existingItem, op.parentKey);
+      const newIndex = this.#items.findIndex((item) => item === existingItem);
       if (newIndex !== prevIndex) {
         delta.push(moveDelta(prevIndex, newIndex, existingItem));
       }
@@ -6576,8 +6701,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (orphan && this.#implicitlyDeletedItems.has(orphan)) {
         orphan._setParentLink(this, op.parentKey);
         this.#implicitlyDeletedItems.delete(orphan);
-        this._insertAndSort(orphan);
-        const recreatedItemIndex = this.#items.indexOf(orphan);
+        const recreatedItemIndex = this.#insert(orphan);
         return {
           modified: makeUpdate(this, [
             // If there is an item at this position, update is a set, else it's an insert
@@ -6588,7 +6712,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       } else {
         if (indexOfItemWithSamePosition !== -1) {
-          this.#items.splice(indexOfItemWithSamePosition, 1);
+          nn(this.#items.removeAt(indexOfItemWithSamePosition));
         }
         const { newItem, newIndex } = this.#createAttachItemAndSort(
           op,
@@ -6647,12 +6771,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
           modified: false
         };
       } else {
-        const oldPositionIndex = this.#items.indexOf(existingItem);
+        const oldPositionIndex = this.#items.findIndex(
+          (item) => item === existingItem
+        );
         if (itemIndexAtPosition !== -1) {
           this.#shiftItemPosition(itemIndexAtPosition, key);
         }
-        existingItem._setParentLink(this, key);
-        this._sortItems();
+        this.#updateItemPosition(existingItem, key);
         const newIndex = this._indexOfPosition(key);
         if (newIndex === oldPositionIndex) {
           return { modified: false };
@@ -6669,7 +6794,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (orphan && this.#implicitlyDeletedItems.has(orphan)) {
         orphan._setParentLink(this, key);
         this.#implicitlyDeletedItems.delete(orphan);
-        this._insertAndSort(orphan);
+        this.#insert(orphan);
         const newIndex = this._indexOfPosition(key);
         return {
           modified: makeUpdate(this, [insertDelta(newIndex, orphan)]),
@@ -6698,12 +6823,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = _optionalChain([this, 'access', _118 => _118.#items, 'access', _119 => _119[existingItemIndex], 'optionalAccess', _120 => _120._parentPos]);
-      const after2 = _optionalChain([this, 'access', _121 => _121.#items, 'access', _122 => _122[existingItemIndex + 1], 'optionalAccess', _123 => _123._parentPos]);
+      const before2 = _optionalChain([this, 'access', _118 => _118.#items, 'access', _119 => _119.at, 'call', _120 => _120(existingItemIndex), 'optionalAccess', _121 => _121._parentPos]);
+      const after2 = _optionalChain([this, 'access', _122 => _122.#items, 'access', _123 => _123.at, 'call', _124 => _124(existingItemIndex + 1), 'optionalAccess', _125 => _125._parentPos]);
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
-    this._insertAndSort(child);
+    this.#insert(child);
     const newIndex = this._indexOfPosition(newKey);
     return {
       modified: makeUpdate(this, [insertDelta(newIndex, child)]),
@@ -6713,7 +6838,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   #applySetUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _124 => _124._pool, 'optionalAccess', _125 => _125.getNode, 'call', _126 => _126(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _126 => _126._pool, 'optionalAccess', _127 => _127.getNode, 'call', _128 => _128(id)]) !== void 0) {
       return { modified: false };
     }
     this.#unacknowledgedSets.set(key, nn(op.opId));
@@ -6722,9 +6847,10 @@ var LiveList = class _LiveList extends AbstractCrdt {
     child._setParentLink(this, key);
     const newKey = key;
     if (indexOfItemWithSameKey !== -1) {
-      const existingItem = this.#items[indexOfItemWithSameKey];
+      const existingItem = this.#items.at(indexOfItemWithSameKey);
       existingItem._detach();
-      this.#items[indexOfItemWithSameKey] = child;
+      this.#items.remove(existingItem);
+      this.#items.add(child);
       const reverse = HACK_addIntentAndDeletedIdToOperation(
         existingItem._toOps(nn(this._id), key),
         op.id
@@ -6741,7 +6867,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
         reverse
       };
     } else {
-      this._insertAndSort(child);
+      this.#insert(child);
       this.#detachItemAssociatedToSetOperation(op.deletedId);
       const newIndex = this._indexOfPosition(newKey);
       return {
@@ -6783,13 +6909,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (child) {
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(nn(this._id), parentKey);
-      const indexToDelete = this.#items.indexOf(child);
+      const indexToDelete = this.#items.findIndex((item) => item === child);
       if (indexToDelete === -1) {
         return {
           modified: false
         };
       }
-      const [previousNode] = this.#items.splice(indexToDelete, 1);
+      const previousNode = this.#items.at(indexToDelete);
+      this.#items.remove(child);
       this.invalidate();
       child._detach();
       return {
@@ -6803,8 +6930,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this.#implicitlyDeletedItems.has(child)) {
       this.#implicitlyDeletedItems.delete(child);
       child._setParentLink(this, newKey);
-      this._insertAndSort(child);
-      const newIndex = this.#items.indexOf(child);
+      const newIndex = this.#insert(child);
       return {
         modified: makeUpdate(this, [insertDelta(newIndex, child)]),
         reverse: []
@@ -6818,10 +6944,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     const existingItemIndex = this._indexOfPosition(newKey);
     if (existingItemIndex === -1) {
-      const previousIndex = this.#items.indexOf(child);
-      child._setParentLink(this, newKey);
-      this._sortItems();
-      const newIndex = this.#items.indexOf(child);
+      const previousIndex = this.#items.findIndex((item) => item === child);
+      this.#updateItemPosition(child, newKey);
+      const newIndex = this.#items.findIndex((item) => item === child);
       if (newIndex === previousIndex) {
         return {
           modified: false
@@ -6832,14 +6957,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
         reverse: []
       };
     } else {
-      this.#items[existingItemIndex]._setParentLink(
-        this,
-        makePosition(newKey, _optionalChain([this, 'access', _127 => _127.#items, 'access', _128 => _128[existingItemIndex + 1], 'optionalAccess', _129 => _129._parentPos]))
+      this.#updateItemPositionAt(
+        existingItemIndex,
+        makePosition(newKey, _optionalChain([this, 'access', _129 => _129.#items, 'access', _130 => _130.at, 'call', _131 => _131(existingItemIndex + 1), 'optionalAccess', _132 => _132._parentPos]))
       );
-      const previousIndex = this.#items.indexOf(child);
-      child._setParentLink(this, newKey);
-      this._sortItems();
-      const newIndex = this.#items.indexOf(child);
+      const previousIndex = this.#items.findIndex((item) => item === child);
+      this.#updateItemPosition(child, newKey);
+      const newIndex = this.#items.findIndex((item) => item === child);
       if (newIndex === previousIndex) {
         return {
           modified: false
@@ -6857,14 +6981,18 @@ var LiveList = class _LiveList extends AbstractCrdt {
       const existingItemIndex = this._indexOfPosition(newKey);
       this.#implicitlyDeletedItems.delete(child);
       if (existingItemIndex !== -1) {
-        this.#items[existingItemIndex]._setParentLink(
+        const existingItem = this.#items.at(existingItemIndex);
+        existingItem._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _130 => _130.#items, 'access', _131 => _131[existingItemIndex + 1], 'optionalAccess', _132 => _132._parentPos]))
+          makePosition(
+            newKey,
+            _optionalChain([this, 'access', _133 => _133.#items, 'access', _134 => _134.at, 'call', _135 => _135(existingItemIndex + 1), 'optionalAccess', _136 => _136._parentPos])
+          )
         );
+        this.#items.reposition(existingItem);
       }
       child._setParentLink(this, newKey);
-      this._insertAndSort(child);
-      const newIndex = this.#items.indexOf(child);
+      const newIndex = this.#insert(child);
       return {
         modified: makeUpdate(this, [insertDelta(newIndex, child)]),
         reverse: []
@@ -6875,17 +7003,19 @@ var LiveList = class _LiveList extends AbstractCrdt {
           modified: false
         };
       }
-      const previousIndex = this.#items.indexOf(child);
+      const previousIndex = this.#items.findIndex((item) => item === child);
       const existingItemIndex = this._indexOfPosition(newKey);
       if (existingItemIndex !== -1) {
-        this.#items[existingItemIndex]._setParentLink(
-          this,
-          makePosition(newKey, _optionalChain([this, 'access', _133 => _133.#items, 'access', _134 => _134[existingItemIndex + 1], 'optionalAccess', _135 => _135._parentPos]))
+        this.#updateItemPositionAt(
+          existingItemIndex,
+          makePosition(
+            newKey,
+            _optionalChain([this, 'access', _137 => _137.#items, 'access', _138 => _138.at, 'call', _139 => _139(existingItemIndex + 1), 'optionalAccess', _140 => _140._parentPos])
+          )
         );
       }
-      child._setParentLink(this, newKey);
-      this._sortItems();
-      const newIndex = this.#items.indexOf(child);
+      this.#updateItemPosition(child, newKey);
+      const newIndex = this.#items.findIndex((item) => item === child);
       if (previousIndex === newIndex) {
         return {
           modified: false
@@ -6902,18 +7032,17 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   #applySetChildKeyUndoRedo(newKey, child) {
     const previousKey = nn(child._parentKey);
-    const previousIndex = this.#items.indexOf(child);
+    const previousIndex = this.#items.findIndex((item) => item === child);
     const existingItemIndex = this._indexOfPosition(newKey);
     let actualNewKey = newKey;
     if (existingItemIndex !== -1) {
       actualNewKey = makePosition(
         newKey,
-        _optionalChain([this, 'access', _136 => _136.#items, 'access', _137 => _137[existingItemIndex + 1], 'optionalAccess', _138 => _138._parentPos])
+        _optionalChain([this, 'access', _141 => _141.#items, 'access', _142 => _142.at, 'call', _143 => _143(existingItemIndex + 1), 'optionalAccess', _144 => _144._parentPos])
       );
     }
-    child._setParentLink(this, actualNewKey);
-    this._sortItems();
-    const newIndex = this.#items.indexOf(child);
+    this.#updateItemPosition(child, actualNewKey);
+    const newIndex = this.#items.findIndex((item) => item === child);
     if (previousIndex === newIndex) {
       return {
         modified: false
@@ -6966,7 +7095,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    _optionalChain([this, 'access', _139 => _139._pool, 'optionalAccess', _140 => _140.assertStorageIsWritable, 'call', _141 => _141()]);
+    _optionalChain([this, 'access', _145 => _145._pool, 'optionalAccess', _146 => _146.assertStorageIsWritable, 'call', _147 => _147()]);
     return this.insert(element, this.length);
   }
   /**
@@ -6975,18 +7104,18 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
-    _optionalChain([this, 'access', _142 => _142._pool, 'optionalAccess', _143 => _143.assertStorageIsWritable, 'call', _144 => _144()]);
+    _optionalChain([this, 'access', _148 => _148._pool, 'optionalAccess', _149 => _149.assertStorageIsWritable, 'call', _150 => _150()]);
     if (index < 0 || index > this.#items.length) {
       throw new Error(
         `Cannot insert list item at index "${index}". index should be between 0 and ${this.#items.length}`
       );
     }
-    const before2 = this.#items[index - 1] ? this.#items[index - 1]._parentPos : void 0;
-    const after2 = this.#items[index] ? this.#items[index]._parentPos : void 0;
+    const before2 = _optionalChain([this, 'access', _151 => _151.#items, 'access', _152 => _152.at, 'call', _153 => _153(index - 1), 'optionalAccess', _154 => _154._parentPos]);
+    const after2 = _optionalChain([this, 'access', _155 => _155.#items, 'access', _156 => _156.at, 'call', _157 => _157(index), 'optionalAccess', _158 => _158._parentPos]);
     const position = makePosition(before2, after2);
     const value = lsonToLiveNode(element);
     value._setParentLink(this, position);
-    this._insertAndSort(value);
+    this.#insert(value);
     if (this._pool && this._id) {
       const id = this._pool.generateId();
       value._attach(id, this._pool);
@@ -7005,7 +7134,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param targetIndex The index where the element should be after moving.
    */
   move(index, targetIndex) {
-    _optionalChain([this, 'access', _145 => _145._pool, 'optionalAccess', _146 => _146.assertStorageIsWritable, 'call', _147 => _147()]);
+    _optionalChain([this, 'access', _159 => _159._pool, 'optionalAccess', _160 => _160.assertStorageIsWritable, 'call', _161 => _161()]);
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
@@ -7023,17 +7152,16 @@ var LiveList = class _LiveList extends AbstractCrdt {
     let beforePosition = null;
     let afterPosition = null;
     if (index < targetIndex) {
-      afterPosition = targetIndex === this.#items.length - 1 ? void 0 : this.#items[targetIndex + 1]._parentPos;
-      beforePosition = this.#items[targetIndex]._parentPos;
+      afterPosition = targetIndex === this.#items.length - 1 ? void 0 : _optionalChain([this, 'access', _162 => _162.#items, 'access', _163 => _163.at, 'call', _164 => _164(targetIndex + 1), 'optionalAccess', _165 => _165._parentPos]);
+      beforePosition = this.#items.at(targetIndex)._parentPos;
     } else {
-      afterPosition = this.#items[targetIndex]._parentPos;
-      beforePosition = targetIndex === 0 ? void 0 : this.#items[targetIndex - 1]._parentPos;
+      afterPosition = this.#items.at(targetIndex)._parentPos;
+      beforePosition = targetIndex === 0 ? void 0 : _optionalChain([this, 'access', _166 => _166.#items, 'access', _167 => _167.at, 'call', _168 => _168(targetIndex - 1), 'optionalAccess', _169 => _169._parentPos]);
     }
     const position = makePosition(beforePosition, afterPosition);
-    const item = this.#items[index];
+    const item = this.#items.at(index);
     const previousPosition = item._getParentKeyOrThrow();
-    item._setParentLink(this, position);
-    this._sortItems();
+    this.#updateItemPositionAt(index, position);
     if (this._pool && this._id) {
       const storageUpdates = /* @__PURE__ */ new Map([
         [this._id, makeUpdate(this, [moveDelta(index, targetIndex, item)])]
@@ -7063,15 +7191,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index of the element to delete
    */
   delete(index) {
-    _optionalChain([this, 'access', _148 => _148._pool, 'optionalAccess', _149 => _149.assertStorageIsWritable, 'call', _150 => _150()]);
+    _optionalChain([this, 'access', _170 => _170._pool, 'optionalAccess', _171 => _171.assertStorageIsWritable, 'call', _172 => _172()]);
     if (index < 0 || index >= this.#items.length) {
       throw new Error(
         `Cannot delete list item at index "${index}". index should be between 0 and ${this.#items.length - 1}`
       );
     }
-    const item = this.#items[index];
+    const item = this.#items.at(index);
     item._detach();
-    const [prev] = this.#items.splice(index, 1);
+    this.#items.remove(item);
     this.invalidate();
     if (this._pool) {
       const childRecordId = item._id;
@@ -7079,7 +7207,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
         const storageUpdates = /* @__PURE__ */ new Map();
         storageUpdates.set(
           nn(this._id),
-          makeUpdate(this, [deleteDelta(index, prev)])
+          makeUpdate(this, [deleteDelta(index, item)])
         );
         this._pool.dispatch(
           [
@@ -7096,7 +7224,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   clear() {
-    _optionalChain([this, 'access', _151 => _151._pool, 'optionalAccess', _152 => _152.assertStorageIsWritable, 'call', _153 => _153()]);
+    _optionalChain([this, 'access', _173 => _173._pool, 'optionalAccess', _174 => _174.assertStorageIsWritable, 'call', _175 => _175()]);
     if (this._pool) {
       const ops = [];
       const reverseOps = [];
@@ -7116,7 +7244,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
           updateDelta.push(deleteDelta(0, item));
         }
       }
-      this.#items = [];
+      this.#items.clear();
       this.invalidate();
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta));
@@ -7125,24 +7253,25 @@ var LiveList = class _LiveList extends AbstractCrdt {
       for (const item of this.#items) {
         item._detach();
       }
-      this.#items = [];
+      this.#items.clear();
       this.invalidate();
     }
   }
   set(index, item) {
-    _optionalChain([this, 'access', _154 => _154._pool, 'optionalAccess', _155 => _155.assertStorageIsWritable, 'call', _156 => _156()]);
+    _optionalChain([this, 'access', _176 => _176._pool, 'optionalAccess', _177 => _177.assertStorageIsWritable, 'call', _178 => _178()]);
     if (index < 0 || index >= this.#items.length) {
       throw new Error(
         `Cannot set list item at index "${index}". index should be between 0 and ${this.#items.length - 1}`
       );
     }
-    const existingItem = this.#items[index];
+    const existingItem = this.#items.at(index);
     const position = existingItem._getParentKeyOrThrow();
     const existingId = existingItem._id;
     existingItem._detach();
     const value = lsonToLiveNode(item);
     value._setParentLink(this, position);
-    this.#items[index] = value;
+    this.#items.remove(existingItem);
+    this.#items.add(value);
     this.invalidate();
     if (this._pool && this._id) {
       const id = this._pool.generateId();
@@ -7165,11 +7294,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * Returns an Array of all the elements in the LiveList.
    */
   toArray() {
-    return this.#items.map(
-      (entry) => liveNodeToLson(entry)
-      //                               ^^^^^^^^
-      //                               FIXME! This isn't safe.
-    );
+    return Array.from(this.#items, (entry) => liveNodeToLson(entry));
   }
   /**
    * Tests whether all elements pass the test implemented by the provided function.
@@ -7219,7 +7344,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (index < 0 || index >= this.#items.length) {
       return void 0;
     }
-    return liveNodeToLson(this.#items[index]);
+    const item = this.#items.at(index);
+    return item ? liveNodeToLson(item) : void 0;
   }
   /**
    * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
@@ -7245,14 +7371,20 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @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
-      )
-    );
+    const result = [];
+    let i = 0;
+    for (const entry of this.#items) {
+      result.push(
+        callback(
+          liveNodeToLson(entry),
+          //                    ^^^^^^^^
+          //                    FIXME! This isn't safe.
+          i
+        )
+      );
+      i++;
+    }
+    return result;
   }
   /**
    * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
@@ -7269,26 +7401,30 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const newItem = creationOpToLiveNode(op);
     newItem._attach(op.id, nn(this._pool));
     newItem._setParentLink(this, key);
-    this._insertAndSort(newItem);
+    this.#insert(newItem);
     const newIndex = this._indexOfPosition(key);
     return { newItem, newIndex };
   }
   #shiftItemPosition(index, key) {
     const shiftedPosition = makePosition(
       key,
-      this.#items.length > index + 1 ? _optionalChain([this, 'access', _157 => _157.#items, 'access', _158 => _158[index + 1], 'optionalAccess', _159 => _159._parentPos]) : void 0
+      this.#items.length > index + 1 ? _optionalChain([this, 'access', _179 => _179.#items, 'access', _180 => _180.at, 'call', _181 => _181(index + 1), 'optionalAccess', _182 => _182._parentPos]) : void 0
     );
-    this.#items[index]._setParentLink(this, shiftedPosition);
+    this.#updateItemPositionAt(index, shiftedPosition);
   }
   /** @internal */
   _toTreeNode(key) {
+    const payload = [];
+    let index = 0;
+    for (const item of this.#items) {
+      payload.push(item.toTreeNode(index.toString()));
+      index++;
+    }
     return {
       type: "LiveList",
       id: _nullishCoalesce(this._id, () => ( nanoid())),
       key,
-      payload: this.#items.map(
-        (item, index) => item.toTreeNode(index.toString())
-      )
+      payload
     };
   }
   toImmutable() {
@@ -7296,11 +7432,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /** @internal */
   _toImmutable() {
-    const result = this.#items.map((node) => node.toImmutable());
+    const result = Array.from(this.#items, (node) => node.toImmutable());
     return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
   }
   clone() {
-    return new _LiveList(this.#items.map((item) => item.clone()));
+    return new _LiveList(
+      Array.from(this.#items, (item) => item.clone())
+    );
   }
 };
 var LiveListIterator = class {
@@ -7541,7 +7679,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @param value The value of the element to add. Should be serializable to JSON.
    */
   set(key, value) {
-    _optionalChain([this, 'access', _160 => _160._pool, 'optionalAccess', _161 => _161.assertStorageIsWritable, 'call', _162 => _162()]);
+    _optionalChain([this, 'access', _183 => _183._pool, 'optionalAccess', _184 => _184.assertStorageIsWritable, 'call', _185 => _185()]);
     const oldValue = this.#map.get(key);
     if (oldValue) {
       oldValue._detach();
@@ -7587,7 +7725,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @returns true if an element existed and has been removed, or false if the element does not exist.
    */
   delete(key) {
-    _optionalChain([this, 'access', _163 => _163._pool, 'optionalAccess', _164 => _164.assertStorageIsWritable, 'call', _165 => _165()]);
+    _optionalChain([this, 'access', _186 => _186._pool, 'optionalAccess', _187 => _187.assertStorageIsWritable, 'call', _188 => _188()]);
     const item = this.#map.get(key);
     if (item === void 0) {
       return false;
@@ -8068,7 +8206,7 @@ var LiveObject = (_class2 = class _LiveObject extends AbstractCrdt {
    * @param value The value of the property to add
    */
   set(key, value) {
-    _optionalChain([this, 'access', _166 => _166._pool, 'optionalAccess', _167 => _167.assertStorageIsWritable, 'call', _168 => _168()]);
+    _optionalChain([this, 'access', _189 => _189._pool, 'optionalAccess', _190 => _190.assertStorageIsWritable, 'call', _191 => _191()]);
     this.update({ [key]: value });
   }
   /**
@@ -8083,7 +8221,7 @@ var LiveObject = (_class2 = class _LiveObject extends AbstractCrdt {
    * @param key The key of the property to delete
    */
   delete(key) {
-    _optionalChain([this, 'access', _169 => _169._pool, 'optionalAccess', _170 => _170.assertStorageIsWritable, 'call', _171 => _171()]);
+    _optionalChain([this, 'access', _192 => _192._pool, 'optionalAccess', _193 => _193.assertStorageIsWritable, 'call', _194 => _194()]);
     const keyAsString = key;
     const oldValue = this.#map.get(keyAsString);
     if (oldValue === void 0) {
@@ -8138,7 +8276,7 @@ var LiveObject = (_class2 = class _LiveObject extends AbstractCrdt {
    * @param patch The object used to overrides properties
    */
   update(patch) {
-    _optionalChain([this, 'access', _172 => _172._pool, 'optionalAccess', _173 => _173.assertStorageIsWritable, 'call', _174 => _174()]);
+    _optionalChain([this, 'access', _195 => _195._pool, 'optionalAccess', _196 => _196.assertStorageIsWritable, 'call', _197 => _197()]);
     if (_LiveObject.detectLargeObjects) {
       const data = {};
       for (const [key, value] of this.#map) {
@@ -8869,15 +9007,15 @@ function installBackgroundTabSpy() {
   const doc = typeof document !== "undefined" ? document : void 0;
   const inBackgroundSince = { current: null };
   function onVisibilityChange() {
-    if (_optionalChain([doc, 'optionalAccess', _175 => _175.visibilityState]) === "hidden") {
+    if (_optionalChain([doc, 'optionalAccess', _198 => _198.visibilityState]) === "hidden") {
       inBackgroundSince.current = _nullishCoalesce(inBackgroundSince.current, () => ( Date.now()));
     } else {
       inBackgroundSince.current = null;
     }
   }
-  _optionalChain([doc, 'optionalAccess', _176 => _176.addEventListener, 'call', _177 => _177("visibilitychange", onVisibilityChange)]);
+  _optionalChain([doc, 'optionalAccess', _199 => _199.addEventListener, 'call', _200 => _200("visibilitychange", onVisibilityChange)]);
   const unsub = () => {
-    _optionalChain([doc, 'optionalAccess', _178 => _178.removeEventListener, 'call', _179 => _179("visibilitychange", onVisibilityChange)]);
+    _optionalChain([doc, 'optionalAccess', _201 => _201.removeEventListener, 'call', _202 => _202("visibilitychange", onVisibilityChange)]);
   };
   return [inBackgroundSince, unsub];
 }
@@ -9063,7 +9201,7 @@ function createRoom(options, config) {
     }
   }
   function isStorageWritable() {
-    const scopes = _optionalChain([context, 'access', _180 => _180.dynamicSessionInfoSig, 'access', _181 => _181.get, 'call', _182 => _182(), 'optionalAccess', _183 => _183.scopes]);
+    const scopes = _optionalChain([context, 'access', _203 => _203.dynamicSessionInfoSig, 'access', _204 => _204.get, 'call', _205 => _205(), 'optionalAccess', _206 => _206.scopes]);
     return scopes !== void 0 ? canWriteStorage(scopes) : true;
   }
   const eventHub = {
@@ -9194,7 +9332,7 @@ function createRoom(options, config) {
       // be stuck in "synchronizing" forever).
       case "experimental-fallback-to-http": {
         warn("Message is too large for websockets, so sending over HTTP instead");
-        const nonce = _nullishCoalesce(_optionalChain([context, 'access', _184 => _184.dynamicSessionInfoSig, 'access', _185 => _185.get, 'call', _186 => _186(), 'optionalAccess', _187 => _187.nonce]), () => ( raise("Session is not authorized to send message over HTTP")));
+        const nonce = _nullishCoalesce(_optionalChain([context, 'access', _207 => _207.dynamicSessionInfoSig, 'access', _208 => _208.get, 'call', _209 => _209(), 'optionalAccess', _210 => _210.nonce]), () => ( raise("Session is not authorized to send message over HTTP")));
         void httpClient.sendMessagesOverHTTP({ roomId, nonce, messages }).then((resp) => {
           if (!resp.ok && resp.status === 403) {
             managedSocket.reconnect();
@@ -9241,15 +9379,24 @@ function createRoom(options, config) {
     (me) => me !== null ? userToTreeNode("Me", me) : null
   );
   function createOrUpdateRootFromMessage(nodes) {
+    if (nodes.size === 0) {
+      throw new Error("Internal error: cannot load storage without items");
+    }
     if (context.root !== void 0) {
-      updateRoot(nodes);
+      const currentItems = /* @__PURE__ */ new Map();
+      for (const [id, crdt] of context.pool.nodes) {
+        currentItems.set(id, crdt._serialize());
+      }
+      const ops = getTreesDiffOperations(currentItems, nodes);
+      const result = applyRemoteOps(ops);
+      notify(result.updates);
     } else {
       context.root = LiveObject._fromItems(
         nodes,
         context.pool
       );
     }
-    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _188 => _188.get, 'call', _189 => _189(), 'optionalAccess', _190 => _190.canWrite]), () => ( true));
+    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _211 => _211.get, 'call', _212 => _212(), 'optionalAccess', _213 => _213.canWrite]), () => ( true));
     const stackSizeBefore = context.undoStack.length;
     for (const key in context.initialStorage) {
       if (context.root.get(key) === void 0) {
@@ -9264,21 +9411,6 @@ function createRoom(options, config) {
     }
     context.undoStack.length = stackSizeBefore;
   }
-  function updateRoot(nodes) {
-    if (nodes.size === 0) {
-      throw new Error("Internal error: cannot load storage without items");
-    }
-    if (context.root === void 0) {
-      return;
-    }
-    const currentItems = /* @__PURE__ */ new Map();
-    for (const [id, crdt] of context.pool.nodes) {
-      currentItems.set(id, crdt._serialize());
-    }
-    const ops = getTreesDiffOperations(currentItems, nodes);
-    const result = applyRemoteOps(ops);
-    notify(result.updates);
-  }
   function _addToRealUndoStack(frames) {
     if (context.undoStack.length >= 50) {
       context.undoStack.shift();
@@ -9468,7 +9600,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _191 => _191.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _214 => _214.addToHistory])) {
         context.activeBatch.reverseOps.pushLeft({
           type: "presence",
           data: oldValues
@@ -9477,7 +9609,7 @@ function createRoom(options, config) {
       context.activeBatch.updates.presence = true;
     } else {
       flushNowOrSoon();
-      if (_optionalChain([options2, 'optionalAccess', _192 => _192.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _215 => _215.addToHistory])) {
         addToUndoStack([{ type: "presence", data: oldValues }]);
       }
       notify({ presence: true });
@@ -9802,7 +9934,7 @@ function createRoom(options, config) {
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(nodes);
     applyAndSendOfflineOps(unacknowledgedOps);
-    _optionalChain([_resolveStoragePromise, 'optionalCall', _193 => _193()]);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _216 => _216()]);
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
   }
@@ -10022,8 +10154,8 @@ function createRoom(options, config) {
   async function getThreads(options2) {
     return httpClient.getThreads({
       roomId,
-      query: _optionalChain([options2, 'optionalAccess', _194 => _194.query]),
-      cursor: _optionalChain([options2, 'optionalAccess', _195 => _195.cursor])
+      query: _optionalChain([options2, 'optionalAccess', _217 => _217.query]),
+      cursor: _optionalChain([options2, 'optionalAccess', _218 => _218.cursor])
     });
   }
   async function getThread(threadId) {
@@ -10145,7 +10277,7 @@ function createRoom(options, config) {
   function getSubscriptionSettings(options2) {
     return httpClient.getSubscriptionSettings({
       roomId,
-      signal: _optionalChain([options2, 'optionalAccess', _196 => _196.signal])
+      signal: _optionalChain([options2, 'optionalAccess', _219 => _219.signal])
     });
   }
   function updateSubscriptionSettings(settings) {
@@ -10167,7 +10299,7 @@ function createRoom(options, config) {
     {
       [kInternal]: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _197 => _197.buffer, 'access', _198 => _198.presenceUpdates, 'optionalAccess', _199 => _199.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _220 => _220.buffer, 'access', _221 => _221.presenceUpdates, 'optionalAccess', _222 => _222.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -10182,9 +10314,9 @@ function createRoom(options, config) {
           return context.yjsProvider;
         },
         setYjsProvider(newProvider) {
-          _optionalChain([context, 'access', _200 => _200.yjsProvider, 'optionalAccess', _201 => _201.off, 'call', _202 => _202("status", yjsStatusDidChange)]);
+          _optionalChain([context, 'access', _223 => _223.yjsProvider, 'optionalAccess', _224 => _224.off, 'call', _225 => _225("status", yjsStatusDidChange)]);
           context.yjsProvider = newProvider;
-          _optionalChain([newProvider, 'optionalAccess', _203 => _203.on, 'call', _204 => _204("status", yjsStatusDidChange)]);
+          _optionalChain([newProvider, 'optionalAccess', _226 => _226.on, 'call', _227 => _227("status", yjsStatusDidChange)]);
           context.yjsProviderDidChange.notify();
         },
         yjsProviderDidChange: context.yjsProviderDidChange.observable,
@@ -10230,7 +10362,7 @@ function createRoom(options, config) {
           source.dispose();
         }
         eventHub.roomWillDestroy.notify();
-        _optionalChain([context, 'access', _205 => _205.yjsProvider, 'optionalAccess', _206 => _206.off, 'call', _207 => _207("status", yjsStatusDidChange)]);
+        _optionalChain([context, 'access', _228 => _228.yjsProvider, 'optionalAccess', _229 => _229.off, 'call', _230 => _230("status", yjsStatusDidChange)]);
         syncSourceForStorage.destroy();
         syncSourceForYjs.destroy();
         uninstallBgTabSpy();
@@ -10381,7 +10513,7 @@ function makeClassicSubscribeFn(roomId, events, errorEvents) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _208 => _208.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _231 => _231.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -10463,8 +10595,8 @@ function createClient(options) {
   const authManager = createAuthManager(options, (token) => {
     currentUserId.set(() => token.uid);
   });
-  const fetchPolyfill = _optionalChain([clientOptions, 'access', _209 => _209.polyfills, 'optionalAccess', _210 => _210.fetch]) || /* istanbul ignore next */
-  _optionalChain([globalThis, 'access', _211 => _211.fetch, 'optionalAccess', _212 => _212.bind, 'call', _213 => _213(globalThis)]);
+  const fetchPolyfill = _optionalChain([clientOptions, 'access', _232 => _232.polyfills, 'optionalAccess', _233 => _233.fetch]) || /* istanbul ignore next */
+  _optionalChain([globalThis, 'access', _234 => _234.fetch, 'optionalAccess', _235 => _235.bind, 'call', _236 => _236(globalThis)]);
   const httpClient = createApiClient({
     baseUrl,
     fetchPolyfill,
@@ -10482,7 +10614,7 @@ function createClient(options) {
     delegates: {
       createSocket: makeCreateSocketDelegateForAi(
         baseUrl,
-        _optionalChain([clientOptions, 'access', _214 => _214.polyfills, 'optionalAccess', _215 => _215.WebSocket])
+        _optionalChain([clientOptions, 'access', _237 => _237.polyfills, 'optionalAccess', _238 => _238.WebSocket])
       ),
       authenticate: async () => {
         const resp = await authManager.getAuthValue({
@@ -10542,7 +10674,7 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             baseUrl,
-            _optionalChain([clientOptions, 'access', _216 => _216.polyfills, 'optionalAccess', _217 => _217.WebSocket]),
+            _optionalChain([clientOptions, 'access', _239 => _239.polyfills, 'optionalAccess', _240 => _240.WebSocket]),
             options2.engine
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
@@ -10567,7 +10699,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.autoConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _218 => _218.polyfills, 'optionalAccess', _219 => _219.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _241 => _241.polyfills, 'optionalAccess', _242 => _242.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"
           );
@@ -10579,7 +10711,7 @@ function createClient(options) {
     return leaseRoom(newRoomDetails);
   }
   function getRoom(roomId) {
-    const room = _optionalChain([roomsById, 'access', _220 => _220.get, 'call', _221 => _221(roomId), 'optionalAccess', _222 => _222.room]);
+    const room = _optionalChain([roomsById, 'access', _243 => _243.get, 'call', _244 => _244(roomId), 'optionalAccess', _245 => _245.room]);
     return room ? room : null;
   }
   function logout() {
@@ -10595,7 +10727,7 @@ function createClient(options) {
   const batchedResolveUsers = new Batch(
     async (batchedUserIds) => {
       const userIds = batchedUserIds.flat();
-      const users = await _optionalChain([resolveUsers, 'optionalCall', _223 => _223({ userIds })]);
+      const users = await _optionalChain([resolveUsers, 'optionalCall', _246 => _246({ userIds })]);
       warnOnceIf(
         !resolveUsers,
         "Set the resolveUsers option in createClient to specify user info."
@@ -10612,7 +10744,7 @@ function createClient(options) {
   const batchedResolveRoomsInfo = new Batch(
     async (batchedRoomIds) => {
       const roomIds = batchedRoomIds.flat();
-      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _224 => _224({ roomIds })]);
+      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _247 => _247({ roomIds })]);
       warnOnceIf(
         !resolveRoomsInfo,
         "Set the resolveRoomsInfo option in createClient to specify room info."
@@ -10629,7 +10761,7 @@ function createClient(options) {
   const batchedResolveGroupsInfo = new Batch(
     async (batchedGroupIds) => {
       const groupIds = batchedGroupIds.flat();
-      const groupsInfo = await _optionalChain([resolveGroupsInfo, 'optionalCall', _225 => _225({ groupIds })]);
+      const groupsInfo = await _optionalChain([resolveGroupsInfo, 'optionalCall', _248 => _248({ groupIds })]);
       warnOnceIf(
         !resolveGroupsInfo,
         "Set the resolveGroupsInfo option in createClient to specify group info."
@@ -10685,7 +10817,7 @@ function createClient(options) {
       }
     };
     const win = typeof window !== "undefined" ? window : void 0;
-    _optionalChain([win, 'optionalAccess', _226 => _226.addEventListener, 'call', _227 => _227("beforeunload", maybePreventClose)]);
+    _optionalChain([win, 'optionalAccess', _249 => _249.addEventListener, 'call', _250 => _250("beforeunload", maybePreventClose)]);
   }
   async function getNotificationSettings(options2) {
     const plainSettings = await httpClient.getNotificationSettings(options2);
@@ -10812,7 +10944,7 @@ var commentBodyElementsTypes = {
   mention: "inline"
 };
 function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
-  if (!body || !_optionalChain([body, 'optionalAccess', _228 => _228.content])) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _251 => _251.content])) {
     return;
   }
   const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
@@ -10822,13 +10954,13 @@ function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
   for (const block of body.content) {
     if (type === "all" || type === "block") {
       if (guard(block)) {
-        _optionalChain([visitor, 'optionalCall', _229 => _229(block)]);
+        _optionalChain([visitor, 'optionalCall', _252 => _252(block)]);
       }
     }
     if (type === "all" || type === "inline") {
       for (const inline of block.children) {
         if (guard(inline)) {
-          _optionalChain([visitor, 'optionalCall', _230 => _230(inline)]);
+          _optionalChain([visitor, 'optionalCall', _253 => _253(inline)]);
         }
       }
     }
@@ -10998,7 +11130,7 @@ var stringifyCommentBodyPlainElements = {
   text: ({ element }) => element.text,
   link: ({ element }) => _nullishCoalesce(element.text, () => ( element.url)),
   mention: ({ element, user, group }) => {
-    return `@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _231 => _231.name]), () => ( _optionalChain([group, 'optionalAccess', _232 => _232.name]))), () => ( element.id))}`;
+    return `@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _254 => _254.name]), () => ( _optionalChain([group, 'optionalAccess', _255 => _255.name]))), () => ( element.id))}`;
   }
 };
 var stringifyCommentBodyHtmlElements = {
@@ -11028,7 +11160,7 @@ var stringifyCommentBodyHtmlElements = {
     return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.text ? html`${element.text}` : element.url}</a>`;
   },
   mention: ({ element, user, group }) => {
-    return html`<span data-mention>@${_optionalChain([user, 'optionalAccess', _233 => _233.name]) ? html`${_optionalChain([user, 'optionalAccess', _234 => _234.name])}` : _optionalChain([group, 'optionalAccess', _235 => _235.name]) ? html`${_optionalChain([group, 'optionalAccess', _236 => _236.name])}` : element.id}</span>`;
+    return html`<span data-mention>@${_optionalChain([user, 'optionalAccess', _256 => _256.name]) ? html`${_optionalChain([user, 'optionalAccess', _257 => _257.name])}` : _optionalChain([group, 'optionalAccess', _258 => _258.name]) ? html`${_optionalChain([group, 'optionalAccess', _259 => _259.name])}` : element.id}</span>`;
   }
 };
 var stringifyCommentBodyMarkdownElements = {
@@ -11058,20 +11190,20 @@ var stringifyCommentBodyMarkdownElements = {
     return markdown`[${_nullishCoalesce(element.text, () => ( element.url))}](${href})`;
   },
   mention: ({ element, user, group }) => {
-    return markdown`@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _237 => _237.name]), () => ( _optionalChain([group, 'optionalAccess', _238 => _238.name]))), () => ( element.id))}`;
+    return markdown`@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _260 => _260.name]), () => ( _optionalChain([group, 'optionalAccess', _261 => _261.name]))), () => ( element.id))}`;
   }
 };
 async function stringifyCommentBody(body, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _239 => _239.format]), () => ( "plain"));
-  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _240 => _240.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _262 => _262.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _263 => _263.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
   const elements = {
     ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ..._optionalChain([options, 'optionalAccess', _241 => _241.elements])
+    ..._optionalChain([options, 'optionalAccess', _264 => _264.elements])
   };
   const { users: resolvedUsers, groups: resolvedGroupsInfo } = await resolveMentionsInCommentBody(
     body,
-    _optionalChain([options, 'optionalAccess', _242 => _242.resolveUsers]),
-    _optionalChain([options, 'optionalAccess', _243 => _243.resolveGroupsInfo])
+    _optionalChain([options, 'optionalAccess', _265 => _265.resolveUsers]),
+    _optionalChain([options, 'optionalAccess', _266 => _266.resolveGroupsInfo])
   );
   const blocks = body.content.flatMap((block, blockIndex) => {
     switch (block.type) {
@@ -11358,12 +11490,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _244 => _244.updates, 'access', _245 => _245[key], 'optionalAccess', _246 => _246.type]) === "update") {
+          if (_optionalChain([update, 'access', _267 => _267.updates, 'access', _268 => _268[key], 'optionalAccess', _269 => _269.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _247 => _247.updates, 'access', _248 => _248[key], 'optionalAccess', _249 => _249.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _270 => _270.updates, 'access', _271 => _271[key], 'optionalAccess', _272 => _272.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -11424,12 +11556,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _250 => _250.updates, 'access', _251 => _251[key], 'optionalAccess', _252 => _252.type]) === "update") {
+          if (_optionalChain([update, 'access', _273 => _273.updates, 'access', _274 => _274[key], 'optionalAccess', _275 => _275.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _253 => _253.updates, 'access', _254 => _254[key], 'optionalAccess', _255 => _255.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _276 => _276.updates, 'access', _277 => _277[key], 'optionalAccess', _278 => _278.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -11509,9 +11641,9 @@ function makePoller(callback, intervalMs, options) {
   const startTime = performance.now();
   const doc = typeof document !== "undefined" ? document : void 0;
   const win = typeof window !== "undefined" ? window : void 0;
-  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _256 => _256.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
+  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _279 => _279.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
   const context = {
-    inForeground: _optionalChain([doc, 'optionalAccess', _257 => _257.visibilityState]) !== "hidden",
+    inForeground: _optionalChain([doc, 'optionalAccess', _280 => _280.visibilityState]) !== "hidden",
     lastSuccessfulPollAt: startTime,
     count: 0,
     backoff: 0
@@ -11592,11 +11724,11 @@ function makePoller(callback, intervalMs, options) {
     pollNowIfStale();
   }
   function onVisibilityChange() {
-    setInForeground(_optionalChain([doc, 'optionalAccess', _258 => _258.visibilityState]) !== "hidden");
+    setInForeground(_optionalChain([doc, 'optionalAccess', _281 => _281.visibilityState]) !== "hidden");
   }
-  _optionalChain([doc, 'optionalAccess', _259 => _259.addEventListener, 'call', _260 => _260("visibilitychange", onVisibilityChange)]);
-  _optionalChain([win, 'optionalAccess', _261 => _261.addEventListener, 'call', _262 => _262("online", onVisibilityChange)]);
-  _optionalChain([win, 'optionalAccess', _263 => _263.addEventListener, 'call', _264 => _264("focus", pollNowIfStale)]);
+  _optionalChain([doc, 'optionalAccess', _282 => _282.addEventListener, 'call', _283 => _283("visibilitychange", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _284 => _284.addEventListener, 'call', _285 => _285("online", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _286 => _286.addEventListener, 'call', _287 => _287("focus", pollNowIfStale)]);
   fsm.start();
   return {
     inc,