@yorkie-js/sdk 0.7.10 → 0.7.11

package/dist/yorkie-js-sdk.js

@@ -6571,447 +6571,432 @@
       this.executedAt = executedAt;
     }
   }
-  class SplayNode {
+  class TreeListNode {
     value;
     left;
     right;
     parent;
     weight;
+    count;
+    red;
     constructor(value) {
       this.value = value;
-      this.initWeight();
-    }
-    /**
-     * `getNodeString` returns a string of weight and value of this node.
-     */
-    getNodeString() {
-      return `${this.weight}${this.value}`;
+      this.red = true;
+      this.weight = this.size();
+      this.count = 1;
     }
     /**
-     * `getValue` returns value of this node.
+     * `getValue` returns the value of this node.
      */
     getValue() {
       return this.value;
     }
     /**
-     * `getLeftWeight` returns left weight of this node.
+     * `size` returns 1 if the node is live, 0 if removed (tombstone).
      */
-    getLeftWeight() {
-      return !this.hasLeft() ? 0 : this.left.getWeight();
+    size() {
+      return this.value.isRemoved() ? 0 : 1;
     }
     /**
-     * `getRightWeight` returns right weight of this node.
+     * `getLeft` returns the left child.
      */
-    getRightWeight() {
-      return !this.hasRight() ? 0 : this.right.getWeight();
+    getLeft() {
+      return this.left;
     }
     /**
-     * `getWeight` returns weight of this node.
+     * `setLeft` sets the left child.
      */
-    getWeight() {
-      return this.weight;
+    setLeft(node) {
+      this.left = node;
     }
     /**
-     * `getLeft` returns a left node.
+     * `getRight` returns the right child.
      */
-    getLeft() {
-      return this.left;
+    getRight() {
+      return this.right;
     }
     /**
-     * `getRight` returns a right node.
+     * `setRight` sets the right child.
      */
-    getRight() {
-      return this.right;
+    setRight(node) {
+      this.right = node;
     }
     /**
-     * `getParent` returns parent of this node.
+     * `getParent` returns the parent.
      */
     getParent() {
       return this.parent;
     }
     /**
-     * `hasLeft` check if the left node exists
+     * `setParent` sets the parent.
      */
-    hasLeft() {
-      return !!this.left;
+    setParent(node) {
+      this.parent = node;
     }
     /**
-     * `hasRight` check if the right node exists
+     * `getWeight` returns the cached live-node weight of this subtree.
      */
-    hasRight() {
-      return !!this.right;
+    getWeight() {
+      return this.weight;
     }
     /**
-     * `hasParent` check if the parent node exists
+     * `setWeight` sets the cached live-node weight of this subtree.
      */
-    hasParent() {
-      return !!this.parent;
+    setWeight(w) {
+      this.weight = w;
     }
     /**
-     * `setLeft` sets a left node.
+     * `getCount` returns the cached total node count of this subtree.
      */
-    setLeft(left) {
-      this.left = left;
+    getCount() {
+      return this.count;
     }
     /**
-     * `setRight` sets a right node.
+     * `setCount` sets the cached total node count of this subtree.
      */
-    setRight(right) {
-      this.right = right;
+    setCount(c) {
+      this.count = c;
     }
     /**
-     * `setParent` sets a parent node.
+     * `isRed` reports whether this node is colored red.
      */
-    setParent(parent) {
-      this.parent = parent;
+    isRed() {
+      return this.red;
     }
     /**
-     * `unlink` unlink parent, right and left node.
+     * `setRed` sets the color of this node.
      */
-    unlink() {
-      this.parent = void 0;
-      this.right = void 0;
-      this.left = void 0;
+    setRed(red) {
+      this.red = red;
     }
     /**
-     * `hasLinks` checks if parent, right and left node exists.
+     * `leftWeight` returns the live-node weight of the left subtree, or 0 if absent.
      */
-    hasLinks() {
-      return this.hasParent() || this.hasLeft() || this.hasRight();
+    leftWeight() {
+      return this.left ? this.left.weight : 0;
     }
     /**
-     * `increaseWeight` increases weight.
+     * `rightWeight` returns the live-node weight of the right subtree, or 0 if absent.
      */
-    increaseWeight(weight) {
-      this.weight += weight;
+    rightWeight() {
+      return this.right ? this.right.weight : 0;
     }
     /**
-     * `initWeight` sets initial weight of this node.
+     * `leftCount` returns the total node count of the left subtree, or 0 if absent.
      */
-    initWeight() {
-      this.weight = this.getLength();
+    leftCount() {
+      return this.left ? this.left.count : 0;
+    }
+    /**
+     * `rightCount` returns the total node count of the right subtree, or 0 if absent.
+     */
+    rightCount() {
+      return this.right ? this.right.count : 0;
     }
   }
-  class SplayTree {
+  function isRed(node) {
+    return !!node && node.isRed();
+  }
+  function updateNode(node) {
+    node.setWeight(node.leftWeight() + node.size() + node.rightWeight());
+    node.setCount(node.leftCount() + 1 + node.rightCount());
+  }
+  function rotateLeft(node) {
+    const right = node.getRight();
+    node.setRight(right.getLeft());
+    if (node.getRight()) {
+      node.getRight().setParent(node);
+    }
+    right.setLeft(node);
+    right.setParent(node.getParent());
+    node.setParent(right);
+    right.setRed(node.isRed());
+    node.setRed(true);
+    updateNode(node);
+    updateNode(right);
+    return right;
+  }
+  function rotateRight(node) {
+    const left = node.getLeft();
+    node.setLeft(left.getRight());
+    if (node.getLeft()) {
+      node.getLeft().setParent(node);
+    }
+    left.setRight(node);
+    left.setParent(node.getParent());
+    node.setParent(left);
+    left.setRed(node.isRed());
+    node.setRed(true);
+    updateNode(node);
+    updateNode(left);
+    return left;
+  }
+  function flipColors(node) {
+    node.setRed(!node.isRed());
+    node.getLeft().setRed(!node.getLeft().isRed());
+    node.getRight().setRed(!node.getRight().isRed());
+  }
+  function moveRedLeft(node) {
+    flipColors(node);
+    if (isRed(node.getRight().getLeft())) {
+      node.setRight(rotateRight(node.getRight()));
+      node.getRight().setParent(node);
+      node = rotateLeft(node);
+      flipColors(node);
+    }
+    return node;
+  }
+  function moveRedRight(node) {
+    flipColors(node);
+    if (isRed(node.getLeft().getLeft())) {
+      node = rotateRight(node);
+      flipColors(node);
+    }
+    return node;
+  }
+  function removeMin(node) {
+    if (!node.getLeft()) {
+      return void 0;
+    }
+    if (!isRed(node.getLeft()) && !isRed(node.getLeft().getLeft())) {
+      node = moveRedLeft(node);
+    }
+    node.setLeft(removeMin(node.getLeft()));
+    if (node.getLeft()) {
+      node.getLeft().setParent(node);
+    }
+    return fixUp(node);
+  }
+  function minNode(node) {
+    while (node.getLeft()) {
+      node = node.getLeft();
+    }
+    return node;
+  }
+  function fixUp(node) {
+    if (isRed(node.getRight()) && !isRed(node.getLeft())) {
+      node = rotateLeft(node);
+    }
+    if (isRed(node.getLeft()) && isRed(node.getLeft().getLeft())) {
+      node = rotateRight(node);
+    }
+    if (isRed(node.getLeft()) && isRed(node.getRight())) {
+      flipColors(node);
+    }
+    updateNode(node);
+    return node;
+  }
+  function traverseInOrder(node, cb) {
+    if (!node) {
+      return;
+    }
+    traverseInOrder(node.getLeft(), cb);
+    cb(node);
+    traverseInOrder(node.getRight(), cb);
+  }
+  class TreeList {
     root;
     constructor(root) {
+      if (root) {
+        root.setRed(false);
+      }
       this.root = root;
     }
     /**
-     * `length` returns the size of this tree.
+     * `length` returns the number of non-removed (live) nodes.
      */
     get length() {
       return this.root ? this.root.getWeight() : 0;
     }
     /**
-     * `findForText` returns the Node and offset of the given position (cursor).
-     * Used for Text where cursor placed between characters.
+     * `insertAfter` inserts the target node right after prev in the in-order
+     * traversal. It uses structural (count-based) indexing to correctly handle
+     * tombstone nodes.
      */
-    findForText(pos) {
-      if (!this.root || pos < 0) {
-        return [void 0, 0];
+    insertAfter(prev, target) {
+      if (!prev || !target) {
+        return;
       }
-      let node = this.root;
-      for (; ; ) {
-        if (node.hasLeft() && pos <= node.getLeftWeight()) {
-          node = node.getLeft();
-        } else if (node.hasRight() && node.getLeftWeight() + node.getLength() < pos) {
-          pos -= node.getLeftWeight() + node.getLength();
-          node = node.getRight();
-        } else {
-          pos -= node.getLeftWeight();
-          break;
-        }
+      target.setLeft(void 0);
+      target.setRight(void 0);
+      target.setParent(void 0);
+      target.setRed(true);
+      target.setWeight(target.size());
+      target.setCount(1);
+      const idx = this.structuralIndexOf(prev);
+      this.root = this.insertByCount(this.root, idx + 1, target);
+      this.root.setRed(false);
+      this.root.setParent(void 0);
+    }
+    /**
+     * `insertByCount` inserts newNode at the given structural index within the
+     * subtree rooted at node, descending the tree using each node's left count
+     * (tombstones included) and rebalancing on the way back up.
+     */
+    insertByCount(node, index, newNode) {
+      if (!node) {
+        return newNode;
       }
-      if (pos > node.getLength()) {
-        throw new YorkieError(
-          Code.ErrInvalidArgument,
-          `out of index range: pos: ${pos} > node.length: ${node.getLength()}`
+      if (index <= node.leftCount()) {
+        node.setLeft(this.insertByCount(node.getLeft(), index, newNode));
+        node.getLeft().setParent(node);
+      } else {
+        node.setRight(
+          this.insertByCount(
+            node.getRight(),
+            index - node.leftCount() - 1,
+            newNode
+          )
         );
+        node.getRight().setParent(node);
       }
-      this.splayNode(node);
-      return [node, pos];
+      return fixUp(node);
     }
     /**
-     * `findForArray` returns the Node of the given position (index).
-     * Used for Array where index points to the element.
+     * `find` returns the node at the given logical index (among non-removed
+     * nodes). Throws when the index is out of range.
      */
-    findForArray(idx) {
-      if (!this.root) {
-        return void 0;
-      }
-      if (idx < 0 || idx >= this.length) {
+    find(index) {
+      if (!this.root || index < 0 || index >= this.length) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
-          `out of index range: idx: ${idx}, length: ${this.length}`
+          `out of index: tree size ${this.length}, index ${index}`
         );
       }
       let node = this.root;
       for (; ; ) {
-        if (node.hasLeft() && idx < node.getLeftWeight()) {
+        if (index < node.leftWeight()) {
           node = node.getLeft();
-        } else if (node.hasRight() && node.getLeftWeight() + node.getLength() <= idx) {
-          idx -= node.getLeftWeight() + node.getLength();
-          node = node.getRight();
-        } else {
+        } else if (index < node.leftWeight() + node.size()) {
           break;
+        } else {
+          index -= node.leftWeight() + node.size();
+          node = node.getRight();
         }
       }
-      this.splayNode(node);
       return node;
     }
     /**
-     * Find the index of the given node in BST.
-     *
-     * @param node - the given node
-     * @returns the index of given node
+     * `delete` physically removes a node from the tree. Unlike tombstoning,
+     * this completely removes the node from the tree structure. It uses
+     * structural (count-based) indexing and swaps the node structure (not
+     * values) with its successor to preserve node identity.
      */
-    indexOf(node) {
-      if (!node || node !== this.root && !node.hasLinks()) {
-        return -1;
+    delete(node) {
+      if (!node || !this.root) {
+        return;
+      }
+      if (!isRed(this.root.getLeft()) && !isRed(this.root.getRight())) {
+        this.root.setRed(true);
+      }
+      const idx = this.structuralIndexOf(node);
+      this.root = this.deleteByCount(this.root, idx);
+      if (this.root) {
+        this.root.setRed(false);
+        this.root.setParent(void 0);
       }
-      this.splayNode(node);
-      return this.root.getLeftWeight();
-    }
-    /**
-     * `getRoot` returns root of this tree.
-     */
-    getRoot() {
-      return this.root;
-    }
-    /**
-     * `insert` inserts the node at the last.
-     */
-    insert(newNode) {
-      return this.insertAfter(this.root, newNode);
     }
     /**
-     * `insertAfter` inserts the node after the given previous node.
+     * `deleteByCount` removes the node at the given structural index within the
+     * subtree rooted at node. When deleting an internal node, it swaps in the
+     * in-order successor by re-parenting rather than copying values so external
+     * references to the surviving node remain valid.
      */
-    insertAfter(target, newNode) {
-      if (!target) {
-        this.root = newNode;
-        return newNode;
-      }
-      this.splayNode(target);
-      this.root = newNode;
-      newNode.setRight(target.getRight());
-      if (target.hasRight()) {
-        target.getRight().setParent(newNode);
+    deleteByCount(node, index) {
+      if (index < node.leftCount()) {
+        if (!isRed(node.getLeft()) && !isRed(node.getLeft().getLeft())) {
+          node = moveRedLeft(node);
+        }
+        node.setLeft(this.deleteByCount(node.getLeft(), index));
+        if (node.getLeft()) {
+          node.getLeft().setParent(node);
+        }
+      } else {
+        if (isRed(node.getLeft())) {
+          node = rotateRight(node);
+        }
+        if (index === node.leftCount() && !node.getRight()) {
+          return void 0;
+        }
+        if (!isRed(node.getRight()) && !isRed(node.getRight().getLeft())) {
+          node = moveRedRight(node);
+        }
+        if (index === node.leftCount()) {
+          const successor = minNode(node.getRight());
+          const newRight = removeMin(node.getRight());
+          successor.setLeft(node.getLeft());
+          successor.setRight(newRight);
+          successor.setRed(node.isRed());
+          if (successor.getLeft()) {
+            successor.getLeft().setParent(successor);
+          }
+          if (successor.getRight()) {
+            successor.getRight().setParent(successor);
+          }
+          node.setLeft(void 0);
+          node.setRight(void 0);
+          node.setParent(void 0);
+          node = successor;
+        } else {
+          node.setRight(
+            this.deleteByCount(node.getRight(), index - node.leftCount() - 1)
+          );
+          if (node.getRight()) {
+            node.getRight().setParent(node);
+          }
+        }
       }
-      newNode.setLeft(target);
-      target.setParent(newNode);
-      target.setRight();
-      this.updateWeight(target);
-      this.updateWeight(newNode);
-      return newNode;
+      return fixUp(node);
     }
     /**
-     * `updateWeight` recalculates the weight of this node with the value and children.
+     * `updateWeight` propagates weight changes from the given node up to the
+     * root. Call this after a node's isRemoved() status changes (i.e., after
+     * tombstoning).
      */
     updateWeight(node) {
-      node.initWeight();
-      if (node.hasLeft()) {
-        node.increaseWeight(node.getLeftWeight());
-      }
-      if (node.hasRight()) {
-        node.increaseWeight(node.getRightWeight());
+      for (let cur = node; cur !== void 0; cur = cur.getParent()) {
+        cur.setWeight(cur.leftWeight() + cur.size() + cur.rightWeight());
       }
     }
-    updateTreeWeight(node) {
-      while (node) {
-        this.updateWeight(node);
-        node = node.getParent();
-      }
+    /**
+     * `toTestString` returns a string containing the metadata of the node for
+     * debugging purpose.
+     */
+    toTestString() {
+      let s = "";
+      traverseInOrder(this.root, (node) => {
+        s += `[${node.getWeight()},${node.size()}]${node.getValue().toString()}`;
+      });
+      return s;
     }
     /**
-     * `splayNode` moves the given node to the root.
+     * `indexOf` returns the logical (live-node) index of the given node, or -1
+     * if the node is a tombstone.
      */
-    splayNode(node) {
-      if (!node) {
-        return;
+    indexOf(node) {
+      if (node.size() === 0) {
+        return -1;
       }
-      for (; ; ) {
-        if (this.isLeftChild(node.getParent()) && this.isRightChild(node)) {
-          this.rotateLeft(node);
-          this.rotateRight(node);
-        } else if (this.isRightChild(node.getParent()) && this.isLeftChild(node)) {
-          this.rotateRight(node);
-          this.rotateLeft(node);
-        } else if (this.isLeftChild(node.getParent()) && this.isLeftChild(node)) {
-          this.rotateRight(node.getParent());
-          this.rotateRight(node);
-        } else if (this.isRightChild(node.getParent()) && this.isRightChild(node)) {
-          this.rotateLeft(node.getParent());
-          this.rotateLeft(node);
-        } else {
-          if (this.isLeftChild(node)) {
-            this.rotateRight(node);
-          } else if (this.isRightChild(node)) {
-            this.rotateLeft(node);
-          }
-          this.updateWeight(node);
-          return;
+      let index = node.leftWeight();
+      for (let cur = node; cur.getParent() !== void 0; cur = cur.getParent()) {
+        if (cur === cur.getParent().getRight()) {
+          index += cur.getParent().leftWeight() + cur.getParent().size();
         }
       }
+      return index;
     }
     /**
-     * `delete` deletes target node of this tree.
+     * `structuralIndexOf` returns the structural position of the node, counting
+     * all nodes including tombstones.
      */
-    delete(node) {
-      this.splayNode(node);
-      const leftTree = new SplayTree(node.getLeft());
-      if (leftTree.root) {
-        leftTree.root.setParent();
-      }
-      const rightTree = new SplayTree(node.getRight());
-      if (rightTree.root) {
-        rightTree.root.setParent();
+    structuralIndexOf(node) {
+      let index = node.leftCount();
+      for (let cur = node; cur.getParent() !== void 0; cur = cur.getParent()) {
+        if (cur === cur.getParent().getRight()) {
+          index += cur.getParent().leftCount() + 1;
+        }
       }
-      if (leftTree.root) {
-        const rightmostNode = leftTree.getRightmost();
-        leftTree.splayNode(rightmostNode);
-        leftTree.root.setRight(rightTree.root);
-        if (rightTree.root) {
-          rightTree.root.setParent(leftTree.root);
-        }
-        this.root = leftTree.root;
-      } else {
-        this.root = rightTree.root;
-      }
-      node.unlink();
-      if (this.root) {
-        this.updateWeight(this.root);
-      }
-    }
-    /**
-     * `deleteRange` separates the range between given 2 boundaries from this Tree.
-     * This function separates the range to delete as a subtree
-     * by splaying outer boundary nodes.
-     * leftBoundary must exist because of 0-indexed initial dummy node of tree,
-     * but rightBoundary can be nil means range to delete includes the end of tree.
-     * Refer to the design document in https://github.com/yorkie-team/yorkie/tree/main/design
-     */
-    deleteRange(leftBoundary, rightBoundary) {
-      if (!rightBoundary) {
-        this.splayNode(leftBoundary);
-        this.cutOffRight(leftBoundary);
-        return;
-      }
-      this.splayNode(leftBoundary);
-      this.splayNode(rightBoundary);
-      if (rightBoundary.getLeft() != leftBoundary) {
-        this.rotateRight(leftBoundary);
-      }
-      this.cutOffRight(leftBoundary);
-    }
-    cutOffRight(root) {
-      const nodesToFreeWeight = [];
-      this.traversePostorder(root.getRight(), nodesToFreeWeight);
-      for (const node of nodesToFreeWeight) {
-        node.initWeight();
-      }
-      this.updateTreeWeight(root);
-    }
-    /**
-     * `toTestString` returns a string containing the meta data of the Node
-     * for debugging purpose.
-     */
-    toTestString() {
-      const metaString = [];
-      this.traverseInorder(this.root, metaString);
-      return metaString.map((n) => `[${n.getWeight()},${n.getLength()}]${n.getValue() || ""}`).join("");
-    }
-    /**
-     * `checkWeight` returns false when there is an incorrect weight node.
-     * for debugging purpose.
-     */
-    checkWeight() {
-      const nodes = [];
-      this.traverseInorder(this.root, nodes);
-      for (const node of nodes) {
-        if (node.getWeight() != node.getLength() + node.getLeftWeight() + node.getRightWeight()) {
-          return false;
-        }
-      }
-      return true;
-    }
-    getRightmost() {
-      let node = this.root;
-      while (node.hasRight()) {
-        node = node.getRight();
-      }
-      return node;
-    }
-    traverseInorder(node, stack) {
-      if (!node) {
-        return;
-      }
-      this.traverseInorder(node.getLeft(), stack);
-      stack.push(node);
-      this.traverseInorder(node.getRight(), stack);
-    }
-    traversePostorder(node, stack) {
-      if (!node) {
-        return;
-      }
-      this.traversePostorder(node.getLeft(), stack);
-      this.traversePostorder(node.getRight(), stack);
-      stack.push(node);
-    }
-    rotateLeft(pivot) {
-      const root = pivot.getParent();
-      if (root.hasParent()) {
-        if (root === root.getParent().getLeft()) {
-          root.getParent().setLeft(pivot);
-        } else {
-          root.getParent().setRight(pivot);
-        }
-      } else {
-        this.root = pivot;
-      }
-      pivot.setParent(root.getParent());
-      root.setRight(pivot.getLeft());
-      if (root.hasRight()) {
-        root.getRight().setParent(root);
-      }
-      pivot.setLeft(root);
-      pivot.getLeft().setParent(pivot);
-      this.updateWeight(root);
-      this.updateWeight(pivot);
-    }
-    rotateRight(pivot) {
-      const root = pivot.getParent();
-      if (root.hasParent()) {
-        if (root === root.getParent().getLeft()) {
-          root.getParent().setLeft(pivot);
-        } else {
-          root.getParent().setRight(pivot);
-        }
-      } else {
-        this.root = pivot;
-      }
-      pivot.setParent(root.getParent());
-      root.setLeft(pivot.getRight());
-      if (root.hasLeft()) {
-        root.getLeft().setParent(root);
-      }
-      pivot.setRight(root);
-      pivot.getRight().setParent(pivot);
-      this.updateWeight(root);
-      this.updateWeight(pivot);
-    }
-    isLeftChild(node) {
-      if (node && node.hasParent()) {
-        return node.getParent().getLeft() === node;
-      }
-      return false;
-    }
-    isRightChild(node) {
-      if (node && node.hasParent()) {
-        return node.getParent().getRight() === node;
-      }
-      return false;
+      return index;
     }
   }
   const removeDecimal = (number) => number < 0 ? Math.ceil(number) : Math.floor(number);
@@ -7301,14 +7286,14 @@
       this.elem = elem;
     }
   }
-  class RGATreeListNode extends SplayNode {
+  class RGATreeListNode {
+    indexNode;
     _elementEntry;
     _createdAt;
     _removedAt;
     prev;
     next;
-    constructor(elem, createdAt) {
-      super(elem);
+    constructor(createdAt) {
       this._createdAt = createdAt;
     }
     /**
@@ -7316,9 +7301,10 @@
      */
     static createWithElement(elem) {
       const entry = new ElementEntry(elem);
-      const node = new RGATreeListNode(elem, elem.getCreatedAt());
-      entry.positionNode = node;
+      const node = new RGATreeListNode(elem.getCreatedAt());
       node._elementEntry = entry;
+      entry.positionNode = node;
+      node.indexNode = new TreeListNode(node);
       return node;
     }
     /**
@@ -7326,7 +7312,9 @@
      * (used for move).
      */
     static createBarePosition(createdAt) {
-      return new RGATreeListNode(void 0, createdAt);
+      const node = new RGATreeListNode(createdAt);
+      node.indexNode = new TreeListNode(node);
+      return node;
     }
     /**
      * `createAfter` creates a new node with the given element after
@@ -7398,14 +7386,14 @@
       this.next = void 0;
     }
     /**
-     * `getLength` returns the length of this node.
-     * Dead nodes (no element) return 0, removed elements return 0.
+     * `toString` returns a string representation of this node's value, used by
+     * TreeList for debugging.
      */
-    getLength() {
-      if (!this._elementEntry || this.isRemoved()) {
-        return 0;
+    toString() {
+      if (!this._elementEntry) {
+        return "";
       }
-      return 1;
+      return this._elementEntry.elem.toJSON();
     }
     /**
      * `getPrev` returns a previous node.
@@ -7423,9 +7411,6 @@
      * `getValue` returns the element value.
      */
     getValue() {
-      if (!this._elementEntry) {
-        return this.value;
-      }
       return this._elementEntry.elem;
     }
     /**
@@ -7514,10 +7499,11 @@
       dummyValue.setRemovedAt(InitialTimeTicket);
       this.dummyHead = RGATreeListNode.createWithElement(dummyValue);
       this.last = this.dummyHead;
-      this.nodeMapByIndex = new SplayTree();
+      this.nodeMapByIndex = new TreeList(
+        this.dummyHead.indexNode
+      );
       this.nodeMapByCreatedAt = /* @__PURE__ */ new Map();
       this.elementMapByCreatedAt = /* @__PURE__ */ new Map();
-      this.nodeMapByIndex.insert(this.dummyHead);
       this.nodeMapByCreatedAt.set(
         this.dummyHead.getCreatedAt().toIDString(),
         this.dummyHead
@@ -7550,7 +7536,7 @@
         this.last = node.getPrev();
       }
       node.release();
-      this.nodeMapByIndex.delete(node);
+      this.nodeMapByIndex.delete(node.indexNode);
       this.nodeMapByCreatedAt.delete(node.getPositionCreatedAt().toIDString());
     }
     /**
@@ -7578,7 +7564,7 @@
       if (prevNode === this.last) {
         this.last = newNode;
       }
-      this.nodeMapByIndex.insertAfter(prevNode, newNode);
+      this.nodeMapByIndex.insertAfter(prevNode.indexNode, newNode.indexNode);
       this.nodeMapByCreatedAt.set(value.getCreatedAt().toIDString(), newNode);
       this.elementMapByCreatedAt.set(
         value.getCreatedAt().toIDString(),
@@ -7605,7 +7591,7 @@
       if (prevNode === this.last) {
         this.last = newNode;
       }
-      this.nodeMapByIndex.insertAfter(prevNode, newNode);
+      this.nodeMapByIndex.insertAfter(prevNode.indexNode, newNode.indexNode);
       this.nodeMapByCreatedAt.set(executedAt.toIDString(), newNode);
       return newNode;
     }
@@ -7634,19 +7620,19 @@
         }
         const deadPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
         deadPosNode.setRemovedAt(executedAt);
-        this.nodeMapByIndex.splayNode(deadPosNode);
+        this.nodeMapByIndex.updateWeight(deadPosNode.indexNode);
         return deadPosNode;
       }
       const newPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
       const oldPosNode = entry.positionNode;
       oldPosNode.setElementEntry(void 0);
       oldPosNode.setRemovedAt(executedAt);
-      this.nodeMapByIndex.splayNode(oldPosNode);
+      this.nodeMapByIndex.updateWeight(oldPosNode.indexNode);
       newPosNode.setElementEntry(entry);
       entry.positionNode = newPosNode;
       entry.posMovedAt = executedAt;
       entry.elem.setMovedAt(executedAt);
-      this.nodeMapByIndex.splayNode(newPosNode);
+      this.nodeMapByIndex.updateWeight(newPosNode.indexNode);
       return oldPosNode;
     }
     /**
@@ -7677,9 +7663,9 @@
         if (!node) {
           return;
         }
-        return String(this.nodeMapByIndex.indexOf(node));
+        return String(this.nodeMapByIndex.indexOf(node.indexNode));
       }
-      return String(this.nodeMapByIndex.indexOf(entry.positionNode));
+      return String(this.nodeMapByIndex.indexOf(entry.positionNode.indexNode));
     }
     /**
      * `purge` physically purges the given child. Handles both dead
@@ -7712,8 +7698,7 @@
       if (idx >= this.length) {
         return;
       }
-      const node = this.nodeMapByIndex.findForArray(idx);
-      return node;
+      return this.nodeMapByIndex.find(idx).getValue();
     }
     /**
      * `findPrevCreatedAt` returns the position node's createdAt of the
@@ -7761,7 +7746,7 @@
       const node = entry.positionNode;
       const alreadyRemoved = node.isRemoved();
       if (entry.elem.remove(editedAt) && !alreadyRemoved) {
-        this.nodeMapByIndex.splayNode(node);
+        this.nodeMapByIndex.updateWeight(node.indexNode);
       }
       return entry.elem;
     }
@@ -7787,7 +7772,7 @@
         return;
       }
       if (node.remove(editedAt)) {
-        this.nodeMapByIndex.splayNode(node);
+        this.nodeMapByIndex.updateWeight(node.indexNode);
       }
       return node.getValue();
     }
@@ -7798,10 +7783,15 @@
       return this.dummyHead.getValue();
     }
     /**
-     * `getLast` returns the value of last elements.
+     * `getLast` returns the value of last elements. Skips bare position nodes
+     * (created by moveAfter/addDeadPosition) that have no element.
      */
     getLast() {
-      return this.last.getValue();
+      let node = this.last;
+      while (!node.getElementEntry() && node !== this.dummyHead) {
+        node = node.getPrev();
+      }
+      return node.getValue();
     }
     /**
      * `getLastCreatedAt` returns the position node's createdAt of the
@@ -7836,7 +7826,7 @@
       const prevNode = this.last;
       RGATreeListNode.insertNodeAfter(prevNode, node);
       this.last = node;
-      this.nodeMapByIndex.insertAfter(prevNode, node);
+      this.nodeMapByIndex.insertAfter(prevNode.indexNode, node.indexNode);
       this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
     }
     /**
@@ -7852,7 +7842,7 @@
       const prevNode = this.last;
       RGATreeListNode.insertNodeAfter(prevNode, node);
       this.last = node;
-      this.nodeMapByIndex.insertAfter(prevNode, node);
+      this.nodeMapByIndex.insertAfter(prevNode.indexNode, node.indexNode);
       this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
       this.elementMapByCreatedAt.set(elem.getCreatedAt().toIDString(), entry);
     }
@@ -8018,9 +8008,10 @@
      */
     *[Symbol.iterator]() {
       for (const node of this.elements) {
-        if (node.getElementEntry() && !node.isRemoved()) {
-          yield node.getValue();
+        if (node.isRemoved()) {
+          continue;
         }
+        yield node.getValue();
       }
     }
     /**
@@ -8445,127 +8436,570 @@
       return `${this.getParentCreatedAt().toTestString()}.SET.${this.key}=${this.value.toSortedJSON()}`;
     }
     /**
-     * `getKey` returns the key of this operation.
+     * `getKey` returns the key of this operation.
+     */
+    getKey() {
+      return this.key;
+    }
+    /**
+     * `getValue` returns the value of this operation.
+     */
+    getValue() {
+      return this.value;
+    }
+  }
+  class MoveOperation extends Operation {
+    prevCreatedAt;
+    createdAt;
+    constructor(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
+      super(parentCreatedAt, executedAt);
+      this.prevCreatedAt = prevCreatedAt;
+      this.createdAt = createdAt;
+    }
+    /**
+     * `create` creates a new instance of MoveOperation.
+     */
+    static create(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
+      return new MoveOperation(
+        parentCreatedAt,
+        prevCreatedAt,
+        createdAt,
+        executedAt
+      );
+    }
+    /**
+     * `execute` executes this operation on the given `CRDTRoot`.
+     */
+    execute(root) {
+      const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
+      if (!parentObject) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `fail to find ${this.getParentCreatedAt()}`
+        );
+      }
+      if (!(parentObject instanceof CRDTArray)) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `fail to execute, only array can execute move`
+        );
+      }
+      const array = parentObject;
+      const reverseOp = this.toReverseOperation(array);
+      const previousIndex = Number(array.subPathOf(this.createdAt));
+      const deadNode = array.moveAfter(
+        this.prevCreatedAt,
+        this.createdAt,
+        this.getExecutedAt()
+      );
+      if (deadNode) {
+        root.registerGCPair({
+          parent: array.getRGATreeList(),
+          child: deadNode
+        });
+      }
+      const index = Number(array.subPathOf(this.createdAt));
+      return {
+        opInfos: [
+          {
+            type: "move",
+            path: root.createPath(this.getParentCreatedAt()),
+            index,
+            previousIndex
+          }
+        ],
+        reverseOp
+      };
+    }
+    toReverseOperation(array) {
+      const preservePrevCreatedAt = array.getPrevCreatedAt(this.createdAt);
+      return MoveOperation.create(
+        this.getParentCreatedAt(),
+        preservePrevCreatedAt,
+        this.createdAt
+      );
+    }
+    /**
+     * `getEffectedCreatedAt` returns the creation time of the
+     * effected element.
+     */
+    getEffectedCreatedAt() {
+      return this.createdAt;
+    }
+    /**
+     * `toTestString` returns a string containing the meta data.
+     */
+    toTestString() {
+      return `${this.getParentCreatedAt().toTestString()}.MOVE`;
+    }
+    /**
+     * `getPrevCreatedAt` returns the creation time of previous
+     * element.
+     */
+    getPrevCreatedAt() {
+      return this.prevCreatedAt;
+    }
+    /**
+     * `getCreatedAt` returns the creation time of the target element.
+     */
+    getCreatedAt() {
+      return this.createdAt;
+    }
+    /**
+     * `setPrevCreatedAt` sets the creation time of the previous
+     * element.
+     */
+    setPrevCreatedAt(createdAt) {
+      this.prevCreatedAt = createdAt;
+    }
+    /**
+     * `setCreatedAt` sets the creation time of the target element.
+     */
+    setCreatedAt(createdAt) {
+      this.createdAt = createdAt;
+    }
+  }
+  class SplayNode {
+    value;
+    left;
+    right;
+    parent;
+    weight;
+    constructor(value) {
+      this.value = value;
+      this.initWeight();
+    }
+    /**
+     * `getNodeString` returns a string of weight and value of this node.
+     */
+    getNodeString() {
+      return `${this.weight}${this.value}`;
+    }
+    /**
+     * `getValue` returns value of this node.
+     */
+    getValue() {
+      return this.value;
+    }
+    /**
+     * `getLeftWeight` returns left weight of this node.
+     */
+    getLeftWeight() {
+      return !this.hasLeft() ? 0 : this.left.getWeight();
+    }
+    /**
+     * `getRightWeight` returns right weight of this node.
+     */
+    getRightWeight() {
+      return !this.hasRight() ? 0 : this.right.getWeight();
+    }
+    /**
+     * `getWeight` returns weight of this node.
+     */
+    getWeight() {
+      return this.weight;
+    }
+    /**
+     * `getLeft` returns a left node.
+     */
+    getLeft() {
+      return this.left;
+    }
+    /**
+     * `getRight` returns a right node.
+     */
+    getRight() {
+      return this.right;
+    }
+    /**
+     * `getParent` returns parent of this node.
+     */
+    getParent() {
+      return this.parent;
+    }
+    /**
+     * `hasLeft` check if the left node exists
+     */
+    hasLeft() {
+      return !!this.left;
+    }
+    /**
+     * `hasRight` check if the right node exists
+     */
+    hasRight() {
+      return !!this.right;
+    }
+    /**
+     * `hasParent` check if the parent node exists
+     */
+    hasParent() {
+      return !!this.parent;
+    }
+    /**
+     * `setLeft` sets a left node.
+     */
+    setLeft(left) {
+      this.left = left;
+    }
+    /**
+     * `setRight` sets a right node.
+     */
+    setRight(right) {
+      this.right = right;
+    }
+    /**
+     * `setParent` sets a parent node.
+     */
+    setParent(parent) {
+      this.parent = parent;
+    }
+    /**
+     * `unlink` unlink parent, right and left node.
+     */
+    unlink() {
+      this.parent = void 0;
+      this.right = void 0;
+      this.left = void 0;
+    }
+    /**
+     * `hasLinks` checks if parent, right and left node exists.
+     */
+    hasLinks() {
+      return this.hasParent() || this.hasLeft() || this.hasRight();
+    }
+    /**
+     * `increaseWeight` increases weight.
+     */
+    increaseWeight(weight) {
+      this.weight += weight;
+    }
+    /**
+     * `initWeight` sets initial weight of this node.
+     */
+    initWeight() {
+      this.weight = this.getLength();
+    }
+  }
+  class SplayTree {
+    root;
+    constructor(root) {
+      this.root = root;
+    }
+    /**
+     * `length` returns the size of this tree.
+     */
+    get length() {
+      return this.root ? this.root.getWeight() : 0;
+    }
+    /**
+     * `findForText` returns the Node and offset of the given position (cursor).
+     * Used for Text where cursor placed between characters.
+     */
+    findForText(pos) {
+      if (!this.root || pos < 0) {
+        return [void 0, 0];
+      }
+      let node = this.root;
+      for (; ; ) {
+        if (node.hasLeft() && pos <= node.getLeftWeight()) {
+          node = node.getLeft();
+        } else if (node.hasRight() && node.getLeftWeight() + node.getLength() < pos) {
+          pos -= node.getLeftWeight() + node.getLength();
+          node = node.getRight();
+        } else {
+          pos -= node.getLeftWeight();
+          break;
+        }
+      }
+      if (pos > node.getLength()) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `out of index range: pos: ${pos} > node.length: ${node.getLength()}`
+        );
+      }
+      this.splayNode(node);
+      return [node, pos];
+    }
+    /**
+     * `findForArray` returns the Node of the given position (index).
+     * Used for Array where index points to the element.
+     */
+    findForArray(idx) {
+      if (!this.root) {
+        return void 0;
+      }
+      if (idx < 0 || idx >= this.length) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `out of index range: idx: ${idx}, length: ${this.length}`
+        );
+      }
+      let node = this.root;
+      for (; ; ) {
+        if (node.hasLeft() && idx < node.getLeftWeight()) {
+          node = node.getLeft();
+        } else if (node.hasRight() && node.getLeftWeight() + node.getLength() <= idx) {
+          idx -= node.getLeftWeight() + node.getLength();
+          node = node.getRight();
+        } else {
+          break;
+        }
+      }
+      this.splayNode(node);
+      return node;
+    }
+    /**
+     * Find the index of the given node in BST.
+     *
+     * @param node - the given node
+     * @returns the index of given node
+     */
+    indexOf(node) {
+      if (!node || node !== this.root && !node.hasLinks()) {
+        return -1;
+      }
+      this.splayNode(node);
+      return this.root.getLeftWeight();
+    }
+    /**
+     * `getRoot` returns root of this tree.
+     */
+    getRoot() {
+      return this.root;
+    }
+    /**
+     * `insert` inserts the node at the last.
+     */
+    insert(newNode) {
+      return this.insertAfter(this.root, newNode);
+    }
+    /**
+     * `insertAfter` inserts the node after the given previous node.
+     */
+    insertAfter(target, newNode) {
+      if (!target) {
+        this.root = newNode;
+        return newNode;
+      }
+      this.splayNode(target);
+      this.root = newNode;
+      newNode.setRight(target.getRight());
+      if (target.hasRight()) {
+        target.getRight().setParent(newNode);
+      }
+      newNode.setLeft(target);
+      target.setParent(newNode);
+      target.setRight();
+      this.updateWeight(target);
+      this.updateWeight(newNode);
+      return newNode;
+    }
+    /**
+     * `updateWeight` recalculates the weight of this node with the value and children.
+     */
+    updateWeight(node) {
+      node.initWeight();
+      if (node.hasLeft()) {
+        node.increaseWeight(node.getLeftWeight());
+      }
+      if (node.hasRight()) {
+        node.increaseWeight(node.getRightWeight());
+      }
+    }
+    updateTreeWeight(node) {
+      while (node) {
+        this.updateWeight(node);
+        node = node.getParent();
+      }
+    }
+    /**
+     * `splayNode` moves the given node to the root.
+     */
+    splayNode(node) {
+      if (!node) {
+        return;
+      }
+      for (; ; ) {
+        if (this.isLeftChild(node.getParent()) && this.isRightChild(node)) {
+          this.rotateLeft(node);
+          this.rotateRight(node);
+        } else if (this.isRightChild(node.getParent()) && this.isLeftChild(node)) {
+          this.rotateRight(node);
+          this.rotateLeft(node);
+        } else if (this.isLeftChild(node.getParent()) && this.isLeftChild(node)) {
+          this.rotateRight(node.getParent());
+          this.rotateRight(node);
+        } else if (this.isRightChild(node.getParent()) && this.isRightChild(node)) {
+          this.rotateLeft(node.getParent());
+          this.rotateLeft(node);
+        } else {
+          if (this.isLeftChild(node)) {
+            this.rotateRight(node);
+          } else if (this.isRightChild(node)) {
+            this.rotateLeft(node);
+          }
+          this.updateWeight(node);
+          return;
+        }
+      }
+    }
+    /**
+     * `delete` deletes target node of this tree.
      */
-    getKey() {
-      return this.key;
+    delete(node) {
+      this.splayNode(node);
+      const leftTree = new SplayTree(node.getLeft());
+      if (leftTree.root) {
+        leftTree.root.setParent();
+      }
+      const rightTree = new SplayTree(node.getRight());
+      if (rightTree.root) {
+        rightTree.root.setParent();
+      }
+      if (leftTree.root) {
+        const rightmostNode = leftTree.getRightmost();
+        leftTree.splayNode(rightmostNode);
+        leftTree.root.setRight(rightTree.root);
+        if (rightTree.root) {
+          rightTree.root.setParent(leftTree.root);
+        }
+        this.root = leftTree.root;
+      } else {
+        this.root = rightTree.root;
+      }
+      node.unlink();
+      if (this.root) {
+        this.updateWeight(this.root);
+      }
     }
     /**
-     * `getValue` returns the value of this operation.
+     * `deleteRange` separates the range between given 2 boundaries from this Tree.
+     * This function separates the range to delete as a subtree
+     * by splaying outer boundary nodes.
+     * leftBoundary must exist because of 0-indexed initial dummy node of tree,
+     * but rightBoundary can be nil means range to delete includes the end of tree.
+     * Refer to the design document in https://github.com/yorkie-team/yorkie/tree/main/design
      */
-    getValue() {
-      return this.value;
+    deleteRange(leftBoundary, rightBoundary) {
+      if (!rightBoundary) {
+        this.splayNode(leftBoundary);
+        this.cutOffRight(leftBoundary);
+        return;
+      }
+      this.splayNode(leftBoundary);
+      this.splayNode(rightBoundary);
+      if (rightBoundary.getLeft() != leftBoundary) {
+        this.rotateRight(leftBoundary);
+      }
+      this.cutOffRight(leftBoundary);
     }
-  }
-  class MoveOperation extends Operation {
-    prevCreatedAt;
-    createdAt;
-    constructor(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
-      super(parentCreatedAt, executedAt);
-      this.prevCreatedAt = prevCreatedAt;
-      this.createdAt = createdAt;
+    cutOffRight(root) {
+      const nodesToFreeWeight = [];
+      this.traversePostorder(root.getRight(), nodesToFreeWeight);
+      for (const node of nodesToFreeWeight) {
+        node.initWeight();
+      }
+      this.updateTreeWeight(root);
     }
     /**
-     * `create` creates a new instance of MoveOperation.
+     * `toTestString` returns a string containing the meta data of the Node
+     * for debugging purpose.
      */
-    static create(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
-      return new MoveOperation(
-        parentCreatedAt,
-        prevCreatedAt,
-        createdAt,
-        executedAt
-      );
+    toTestString() {
+      const metaString = [];
+      this.traverseInorder(this.root, metaString);
+      return metaString.map((n) => `[${n.getWeight()},${n.getLength()}]${n.getValue() || ""}`).join("");
     }
     /**
-     * `execute` executes this operation on the given `CRDTRoot`.
+     * `checkWeight` returns false when there is an incorrect weight node.
+     * for debugging purpose.
      */
-    execute(root) {
-      const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
-      if (!parentObject) {
-        throw new YorkieError(
-          Code.ErrInvalidArgument,
-          `fail to find ${this.getParentCreatedAt()}`
-        );
-      }
-      if (!(parentObject instanceof CRDTArray)) {
-        throw new YorkieError(
-          Code.ErrInvalidArgument,
-          `fail to execute, only array can execute move`
-        );
-      }
-      const array = parentObject;
-      const reverseOp = this.toReverseOperation(array);
-      const previousIndex = Number(array.subPathOf(this.createdAt));
-      const deadNode = array.moveAfter(
-        this.prevCreatedAt,
-        this.createdAt,
-        this.getExecutedAt()
-      );
-      if (deadNode) {
-        root.registerGCPair({
-          parent: array.getRGATreeList(),
-          child: deadNode
-        });
+    checkWeight() {
+      const nodes = [];
+      this.traverseInorder(this.root, nodes);
+      for (const node of nodes) {
+        if (node.getWeight() != node.getLength() + node.getLeftWeight() + node.getRightWeight()) {
+          return false;
+        }
       }
-      const index = Number(array.subPathOf(this.createdAt));
-      return {
-        opInfos: [
-          {
-            type: "move",
-            path: root.createPath(this.getParentCreatedAt()),
-            index,
-            previousIndex
-          }
-        ],
-        reverseOp
-      };
+      return true;
     }
-    toReverseOperation(array) {
-      const preservePrevCreatedAt = array.getPrevCreatedAt(this.createdAt);
-      return MoveOperation.create(
-        this.getParentCreatedAt(),
-        preservePrevCreatedAt,
-        this.createdAt
-      );
+    getRightmost() {
+      let node = this.root;
+      while (node.hasRight()) {
+        node = node.getRight();
+      }
+      return node;
     }
-    /**
-     * `getEffectedCreatedAt` returns the creation time of the
-     * effected element.
-     */
-    getEffectedCreatedAt() {
-      return this.createdAt;
+    traverseInorder(node, stack) {
+      if (!node) {
+        return;
+      }
+      this.traverseInorder(node.getLeft(), stack);
+      stack.push(node);
+      this.traverseInorder(node.getRight(), stack);
     }
-    /**
-     * `toTestString` returns a string containing the meta data.
-     */
-    toTestString() {
-      return `${this.getParentCreatedAt().toTestString()}.MOVE`;
+    traversePostorder(node, stack) {
+      if (!node) {
+        return;
+      }
+      this.traversePostorder(node.getLeft(), stack);
+      this.traversePostorder(node.getRight(), stack);
+      stack.push(node);
     }
-    /**
-     * `getPrevCreatedAt` returns the creation time of previous
-     * element.
-     */
-    getPrevCreatedAt() {
-      return this.prevCreatedAt;
+    rotateLeft(pivot) {
+      const root = pivot.getParent();
+      if (root.hasParent()) {
+        if (root === root.getParent().getLeft()) {
+          root.getParent().setLeft(pivot);
+        } else {
+          root.getParent().setRight(pivot);
+        }
+      } else {
+        this.root = pivot;
+      }
+      pivot.setParent(root.getParent());
+      root.setRight(pivot.getLeft());
+      if (root.hasRight()) {
+        root.getRight().setParent(root);
+      }
+      pivot.setLeft(root);
+      pivot.getLeft().setParent(pivot);
+      this.updateWeight(root);
+      this.updateWeight(pivot);
     }
-    /**
-     * `getCreatedAt` returns the creation time of the target element.
-     */
-    getCreatedAt() {
-      return this.createdAt;
+    rotateRight(pivot) {
+      const root = pivot.getParent();
+      if (root.hasParent()) {
+        if (root === root.getParent().getLeft()) {
+          root.getParent().setLeft(pivot);
+        } else {
+          root.getParent().setRight(pivot);
+        }
+      } else {
+        this.root = pivot;
+      }
+      pivot.setParent(root.getParent());
+      root.setLeft(pivot.getRight());
+      if (root.hasLeft()) {
+        root.getLeft().setParent(root);
+      }
+      pivot.setRight(root);
+      pivot.getRight().setParent(pivot);
+      this.updateWeight(root);
+      this.updateWeight(pivot);
     }
-    /**
-     * `setPrevCreatedAt` sets the creation time of the previous
-     * element.
-     */
-    setPrevCreatedAt(createdAt) {
-      this.prevCreatedAt = createdAt;
+    isLeftChild(node) {
+      if (node && node.hasParent()) {
+        return node.getParent().getLeft() === node;
+      }
+      return false;
     }
-    /**
-     * `setCreatedAt` sets the creation time of the target element.
-     */
-    setCreatedAt(createdAt) {
-      this.createdAt = createdAt;
+    isRightChild(node) {
+      if (node && node.hasParent()) {
+        return node.getParent().getRight() === node;
+      }
+      return false;
     }
   }
   const DefaultComparator = (a, b) => {
@@ -8583,10 +9017,10 @@
     left;
     right;
     isRed;
-    constructor(key, value, isRed) {
+    constructor(key, value, isRed2) {
       this.key = key;
       this.value = value;
-      this.isRed = isRed;
+      this.isRed = isRed2;
     }
   }
   class SortedMapIterator {
@@ -13770,6 +14204,26 @@
       newID.versionVector.set(this.actor, lamport);
       return newID;
     }
+    /**
+     * `syncLamport` advances the lamport clock against the given ID without
+     * merging its version vector into the receiver's. It is the counterpart
+     * of `syncClocks` for attachments that have opted out of GC participation
+     * (see docs/design/disable-gc-on-attach.md in the server repo): the
+     * receiver does not need other actors' entries in its VV because it
+     * never produces or consumes tombstones, and dropping them keeps each
+     * subsequent local Change's VV at O(1) instead of O(num_actors).
+     * Lamport must still advance so that TimeTickets produced locally
+     * remain ordered against remote operations.
+     */
+    syncLamport(other) {
+      if (!other.hasClocks()) {
+        return this;
+      }
+      const lamport = other.lamport > this.lamport ? other.lamport + 1n : this.lamport + 1n;
+      const vector = this.versionVector.deepcopy();
+      vector.set(this.actor, lamport);
+      return new ChangeID(this.clientSeq, lamport, this.actor, vector);
+    }
     /**
      * `setClocks` sets the given clocks to this ID. This is used when the snapshot
      * is given from the server.
@@ -19646,6 +20100,12 @@
     onlineClients;
     eventStream;
     eventStreamObserver;
+    // `disableGC`, when true, declares that this document does not produce or
+    // consume tombstones (see disable-gc-on-attach in the server repo). It is
+    // set by the client on Attach and consumed by applyChange to skip merging
+    // remote actors' version vectors into changeID, keeping each subsequent
+    // local Change's VV at O(1) for high-fan-out Counter workloads.
+    disableGC;
     /**
      * `history` is exposed to the user to manage undo/redo operations.
      */
@@ -19659,6 +20119,7 @@
       this.changeID = InitialChangeID;
       this.checkpoint = InitialCheckpoint;
       this.localChanges = [];
+      this.disableGC = false;
       this.root = CRDTRoot.create();
       this.presences = /* @__PURE__ */ new Map();
       this.onlineClients = /* @__PURE__ */ new Set();
@@ -20067,6 +20528,14 @@
       }
       this.changeID = this.changeID.setActor(actorID);
     }
+    /**
+     * `setDisableGC` records whether this document participates in GC. The
+     * client calls this on attach so subsequent applyChange runs use the
+     * lamport-only sync path.
+     */
+    setDisableGC(disableGC) {
+      this.disableGC = disableGC;
+    }
     /**
      * `isEnableDevtools` returns whether devtools is enabled or not.
      */
@@ -20305,7 +20774,7 @@
           );
         }
       }
-      this.changeID = this.changeID.syncClocks(change.getID());
+      this.changeID = this.disableGC ? this.changeID.syncLamport(change.getID()) : this.changeID.syncClocks(change.getID());
       if (opInfos.length) {
         const rawChange = this.isEnableDevtools() ? change.toStruct() : void 0;
         events.push(
@@ -20988,7 +21457,7 @@
     };
   }
   const name = "@yorkie-js/sdk";
-  const version = "0.7.10";
+  const version = "0.7.11";
   const pkg = {
     name,
     version
@@ -21549,6 +22018,7 @@
             doc.setSchemaRules(converter.fromSchemaRules(res.schemaRules));
           }
           const pack = converter.fromChangePack(res.changePack);
+          doc.setDisableGC(opts.disableGC ?? false);
           doc.applyChangePack(pack);
           if (doc.getStatus() === DocStatus.Removed) {
             return doc;