npm - @yorkie-js/react - Versions diffs - 0.7.5 → 0.7.7 - Mend

@yorkie-js/react 0.7.5 → 0.7.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/yorkie-js-react.es.js +955 -261
package/dist/yorkie-js-react.es.js.map +1 -1
package/dist/yorkie-js-react.js +955 -261
package/dist/yorkie-js-react.js.map +1 -1
package/package.json +2 -2

package/dist/yorkie-js-react.js CHANGED Viewed

@@ -5792,7 +5792,7 @@
       }
     };
   }
-  const file_src_api_yorkie_v1_resources = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
+  const file_src_api_yorkie_v1_resources = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
   const SnapshotSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 0);
   const ChangePackSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 1);
   const ChangeSchema = /* @__PURE__ */ messageDesc(file_src_api_yorkie_v1_resources, 2);
@@ -7141,6 +7141,13 @@
       if (this.valueType === 5) {
         return `"${escapeString(this.value)}"`;
       }
+      if (this.valueType === 6) {
+        const bytes = this.value;
+        return `"${btoa(String.fromCharCode(...bytes))}"`;
+      }
+      if (this.valueType === 7) {
+        return `"${this.value.toISOString()}"`;
+      }
       return `${this.value}`;
     }
     /**
@@ -7283,19 +7290,54 @@
       }
     }
   }
+  class ElementEntry {
+    elem;
+    positionNode;
+    posMovedAt;
+    constructor(elem) {
+      this.elem = elem;
+    }
+  }
   class RGATreeListNode extends SplayNode {
+    _elementEntry;
+    _createdAt;
+    _removedAt;
     prev;
     next;
-    movedFrom;
-    constructor(value) {
-      super(value);
-      this.value = value;
+    constructor(elem, createdAt) {
+      super(elem);
+      this._createdAt = createdAt;
+    }
+    /**
+     * `createWithElement` creates a new node that owns an element.
+     */
+    static createWithElement(elem) {
+      const entry = new ElementEntry(elem);
+      const node = new RGATreeListNode(elem, elem.getCreatedAt());
+      entry.positionNode = node;
+      node._elementEntry = entry;
+      return node;
+    }
+    /**
+     * `createBarePosition` creates a position node without an element
+     * (used for move).
+     */
+    static createBarePosition(createdAt) {
+      return new RGATreeListNode(void 0, createdAt);
     }
     /**
-     * `createAfter` creates a new node after the given node.
+     * `createAfter` creates a new node with the given element after
+     * the given prev node.
      */
-    static createAfter(prev, value) {
-      const newNode = new RGATreeListNode(value);
+    static createAfter(prev, elem) {
+      const newNode = RGATreeListNode.createWithElement(elem);
+      RGATreeListNode.insertNodeAfter(prev, newNode);
+      return newNode;
+    }
+    /**
+     * `insertNodeAfter` inserts a node after the given prev node.
+     */
+    static insertNodeAfter(prev, newNode) {
       const prevNext = prev.next;
       prev.next = newNode;
       newNode.prev = prev;
@@ -7303,26 +7345,41 @@
       if (prevNext) {
         prevNext.prev = newNode;
       }
-      return newNode;
     }
     /**
-     * `remove` removes value based on removing time.
+     * `remove` removes the element based on removing time.
      */
     remove(removedAt) {
-      return this.value.remove(removedAt);
+      if (!this._elementEntry) {
+        return false;
+      }
+      return this._elementEntry.elem.remove(removedAt);
     }
     /**
-     * `getCreatedAt` returns creation time of this value
+     * `getCreatedAt` returns the creation time. For live nodes with
+     * elements, returns the element's createdAt for backward
+     * compatibility.
      */
     getCreatedAt() {
-      return this.value.getCreatedAt();
+      if (this._elementEntry) {
+        return this._elementEntry.elem.getCreatedAt();
+      }
+      return this._createdAt;
     }
     /**
-     * `getPositionedAt` returns the time of this element when it was positioned
-     * in the array.
+     * `getPositionedAt` returns the time this element was positioned.
+     * For live nodes, the position register (posMovedAt) is the source
+     * of truth. For dead nodes (no element), the position node's own
+     * createdAt is used.
      */
     getPositionedAt() {
-      return this.value.getPositionedAt();
+      if (this._elementEntry) {
+        if (this._elementEntry.posMovedAt) {
+          return this._elementEntry.posMovedAt;
+        }
+        return this._elementEntry.elem.getCreatedAt();
+      }
+      return this._createdAt;
     }
     /**
      * `release` releases prev and next node.
@@ -7339,9 +7396,13 @@
     }
     /**
      * `getLength` returns the length of this node.
+     * Dead nodes (no element) return 0, removed elements return 0.
      */
     getLength() {
-      return this.value.isRemoved() ? 0 : 1;
+      if (!this._elementEntry || this.isRemoved()) {
+        return 0;
+      }
+      return 1;
     }
     /**
      * `getPrev` returns a previous node.
@@ -7356,28 +7417,87 @@
       return this.next;
     }
     /**
-     * `getMovedFrom` returns the previous element before the element moved.
+     * `getValue` returns the element value.
      */
-    getMovedFrom() {
-      return this.movedFrom;
+    getValue() {
+      if (!this._elementEntry) {
+        return this.value;
+      }
+      return this._elementEntry.elem;
     }
     /**
-     * `setMovedFrom` sets the previous element before the element moved.
+     * `getElement` returns the element or undefined if dead position.
      */
-    setMovedFrom(movedFrom) {
-      this.movedFrom = movedFrom;
+    getElement() {
+      return this._elementEntry?.elem;
     }
     /**
-     * `getValue` returns a element value.
+     * `isRemoved` checks if the value was removed.
      */
-    getValue() {
-      return this.value;
+    isRemoved() {
+      if (!this._elementEntry) {
+        return true;
+      }
+      return this._elementEntry.elem.isRemoved();
     }
     /**
-     * `isRemoved` checks if the value was removed.
+     * `getElementEntry` returns the element entry.
      */
-    isRemoved() {
-      return this.value.isRemoved();
+    getElementEntry() {
+      return this._elementEntry;
+    }
+    /**
+     * `setElementEntry` sets the element entry.
+     */
+    setElementEntry(entry) {
+      this._elementEntry = entry;
+    }
+    /**
+     * `getPositionCreatedAt` returns the position node's own createdAt.
+     */
+    getPositionCreatedAt() {
+      return this._createdAt;
+    }
+    /**
+     * `getPositionMovedAt` returns the LWW timestamp of the element's
+     * move into this position. Undefined for insert-created positions.
+     */
+    getPositionMovedAt() {
+      if (!this._elementEntry) {
+        return void 0;
+      }
+      return this._elementEntry.posMovedAt;
+    }
+    /**
+     * `getRemovedAt` returns the time this dead position node was
+     * removed (for GC).
+     */
+    getRemovedAt() {
+      return this._removedAt;
+    }
+    /**
+     * `setRemovedAt` sets the removal time of this position node.
+     */
+    setRemovedAt(removedAt) {
+      this._removedAt = removedAt;
+    }
+    /**
+     * `toIDString` returns a unique identifier for this position node
+     * (for GC).
+     */
+    toIDString() {
+      return this._createdAt.toIDString();
+    }
+    /**
+     * `getDataSize` returns the data size of this position node
+     * (for GC).
+     */
+    getDataSize() {
+      let meta = TimeTicketSize;
+      if (this._removedAt) {
+        meta += TimeTicketSize;
+      }
+      return { data: 0, meta };
     }
   }
   class RGATreeList {
@@ -7385,13 +7505,15 @@
     last;
     nodeMapByIndex;
     nodeMapByCreatedAt;
+    elementMapByCreatedAt;
     constructor() {
       const dummyValue = Primitive.of(0, InitialTimeTicket);
       dummyValue.setRemovedAt(InitialTimeTicket);
-      this.dummyHead = new RGATreeListNode(dummyValue);
+      this.dummyHead = RGATreeListNode.createWithElement(dummyValue);
       this.last = this.dummyHead;
       this.nodeMapByIndex = new SplayTree();
       this.nodeMapByCreatedAt = /* @__PURE__ */ new Map();
+      this.elementMapByCreatedAt = /* @__PURE__ */ new Map();
       this.nodeMapByIndex.insert(this.dummyHead);
       this.nodeMapByCreatedAt.set(
         this.dummyHead.getCreatedAt().toIDString(),
@@ -7411,22 +7533,10 @@
       return this.nodeMapByIndex.length;
     }
     /**
-     * `findNextBeforeExecutedAt` returns the node by the given createdAt and
-     * executedAt. It passes through nodes created after executedAt from the
-     * given node and returns the next node.
-     * @returns the next node of the given createdAt and executedAt
+     * `findNextBeforeExecutedAt` walks forward from the given node,
+     * skipping nodes positioned after executedAt (RGA insertion rule).
      */
-    findNextBeforeExecutedAt(createdAt, executedAt) {
-      let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-      if (!node) {
-        throw new YorkieError(
-          Code.ErrInvalidArgument,
-          `cant find the given node: ${createdAt.toIDString()}`
-        );
-      }
-      while (node.getValue().getMovedAt() && node.getValue().getMovedAt().after(executedAt) && node.getMovedFrom()) {
-        node = node.getMovedFrom();
-      }
+    findNextBeforeExecutedAt(node, executedAt) {
       while (node.getNext() && node.getNext().getPositionedAt().after(executedAt)) {
         node = node.getNext();
       }
@@ -7438,65 +7548,103 @@
       }
       node.release();
       this.nodeMapByIndex.delete(node);
-      this.nodeMapByCreatedAt.delete(node.getValue().getCreatedAt().toIDString());
+      this.nodeMapByCreatedAt.delete(node.getPositionCreatedAt().toIDString());
     }
     /**
-     * `insertAfter` adds a new node with the value after the given node.
+     * `insertAfter` adds a new node with the value after the given
+     * position. prevCreatedAt is a position node identity. Looks up
+     * nodeMapByCreatedAt first, then elementMapByCreatedAt for backward
+     * compatibility.
      */
     insertAfter(prevCreatedAt, value, executedAt = value.getCreatedAt()) {
-      const prevNode = this.findNextBeforeExecutedAt(prevCreatedAt, executedAt);
+      let startNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
+      if (!startNode) {
+        const entry = this.elementMapByCreatedAt.get(prevCreatedAt.toIDString());
+        if (entry) {
+          startNode = entry.positionNode;
+        }
+      }
+      if (!startNode) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${prevCreatedAt.toIDString()}`
+        );
+      }
+      const prevNode = this.findNextBeforeExecutedAt(startNode, executedAt);
       const newNode = RGATreeListNode.createAfter(prevNode, value);
       if (prevNode === this.last) {
         this.last = newNode;
       }
       this.nodeMapByIndex.insertAfter(prevNode, newNode);
-      this.nodeMapByCreatedAt.set(newNode.getCreatedAt().toIDString(), newNode);
+      this.nodeMapByCreatedAt.set(value.getCreatedAt().toIDString(), newNode);
+      this.elementMapByCreatedAt.set(
+        value.getCreatedAt().toIDString(),
+        newNode.getElementEntry()
+      );
       return newNode;
     }
     /**
-     * `moveAfter` moves the given `createdAt` element
-     * after the `prevCreatedAt` element.
+     * `insertPositionAfter` creates a bare position node after
+     * resolving position via forward skip (RGA insertion rule).
+     * Used by moveAfter. prevCreatedAt is a POSITION node identity.
+     */
+    insertPositionAfter(prevCreatedAt, executedAt) {
+      const startNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
+      if (!startNode) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${prevCreatedAt.toIDString()}`
+        );
+      }
+      const prevNode = this.findNextBeforeExecutedAt(startNode, executedAt);
+      const newNode = RGATreeListNode.createBarePosition(executedAt);
+      RGATreeListNode.insertNodeAfter(prevNode, newNode);
+      if (prevNode === this.last) {
+        this.last = newNode;
+      }
+      this.nodeMapByIndex.insertAfter(prevNode, newNode);
+      this.nodeMapByCreatedAt.set(executedAt.toIDString(), newNode);
+      return newNode;
+    }
+    /**
+     * `moveAfter` moves the given `createdAt` element after the
+     * `prevCreatedAt` element using LWW position register semantics.
+     * Returns the dead position node (if any) for GC registration.
      */
     moveAfter(prevCreatedAt, createdAt, executedAt) {
-      let prevNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
-      if (!prevNode) {
+      if (!this.nodeMapByCreatedAt.has(prevCreatedAt.toIDString())) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `cant find the given node: ${prevCreatedAt.toIDString()}`
         );
       }
-      let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-      if (!node) {
+      const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+      if (!entry) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `cant find the given node: ${createdAt.toIDString()}`
         );
       }
-      if (prevNode !== node && executedAt.after(node.getPositionedAt())) {
-        const movedFrom = node.getPrev();
-        let nextNode = node.getNext();
-        this.release(node);
-        node = this.insertAfter(
-          prevNode.getCreatedAt(),
-          node.getValue(),
-          executedAt
-        );
-        node.getValue().setMovedAt(executedAt);
-        node.setMovedFrom(movedFrom);
-        while (nextNode && nextNode.getPositionedAt().after(executedAt)) {
-          prevNode = node;
-          node = nextNode;
-          nextNode = node.getNext();
-          this.release(node);
-          node = this.insertAfter(
-            prevNode.getCreatedAt(),
-            node.getValue(),
-            executedAt
-          );
-          node.getValue().setMovedAt(executedAt);
-          node.setMovedFrom(movedFrom);
+      if (entry.posMovedAt && !executedAt.after(entry.posMovedAt)) {
+        if (this.nodeMapByCreatedAt.has(executedAt.toIDString())) {
+          return void 0;
         }
+        const deadPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
+        deadPosNode.setRemovedAt(executedAt);
+        this.nodeMapByIndex.splayNode(deadPosNode);
+        return deadPosNode;
       }
+      const newPosNode = this.insertPositionAfter(prevCreatedAt, executedAt);
+      const oldPosNode = entry.positionNode;
+      oldPosNode.setElementEntry(void 0);
+      oldPosNode.setRemovedAt(executedAt);
+      this.nodeMapByIndex.splayNode(oldPosNode);
+      newPosNode.setElementEntry(entry);
+      entry.positionNode = newPosNode;
+      entry.posMovedAt = executedAt;
+      entry.elem.setMovedAt(executedAt);
+      this.nodeMapByIndex.splayNode(newPosNode);
+      return oldPosNode;
     }
     /**
      * `insert` adds the given element after the last node.
@@ -7505,34 +7653,53 @@
       this.insertAfter(this.last.getCreatedAt(), value);
     }
     /**
-     * `getByID` returns the element of the given creation time.
+     * `getByID` returns the node of the given creation time.
+     * Checks elementMapByCreatedAt first (for moved elements whose
+     * position node createdAt differs), then nodeMapByCreatedAt.
      */
     getByID(createdAt) {
+      const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+      if (entry) {
+        return entry.positionNode;
+      }
       return this.nodeMapByCreatedAt.get(createdAt.toIDString());
     }
     /**
      * `subPathOf` returns the sub path of the given element.
      */
     subPathOf(createdAt) {
-      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-      if (!node) {
-        return;
+      const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+      if (!entry) {
+        const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+        if (!node) {
+          return;
+        }
+        return String(this.nodeMapByIndex.indexOf(node));
       }
-      return String(this.nodeMapByIndex.indexOf(node));
+      return String(this.nodeMapByIndex.indexOf(entry.positionNode));
     }
     /**
-     * `purge` physically purges element.
+     * `purge` physically purges the given child. Handles both dead
+     * position nodes (GCChild from GCParent path) and CRDTElements
+     * (from CRDTContainer path).
      */
-    purge(element) {
-      const node = this.nodeMapByCreatedAt.get(
+    purge(child) {
+      if (child instanceof RGATreeListNode) {
+        this.release(child);
+        return;
+      }
+      const element = child;
+      const entry = this.elementMapByCreatedAt.get(
         element.getCreatedAt().toIDString()
       );
-      if (!node) {
+      if (!entry) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `fail to find the given createdAt: ${element.getCreatedAt().toIDString()}`
         );
       }
+      const node = entry.positionNode;
+      this.elementMapByCreatedAt.delete(element.getCreatedAt().toIDString());
       this.release(node);
     }
     /**
@@ -7543,42 +7710,69 @@
         return;
       }
       const node = this.nodeMapByIndex.findForArray(idx);
-      const rgaNode = node;
-      return rgaNode;
+      return node;
     }
     /**
-     * `getPrevCreatedAt` returns a creation time of the previous node.
+     * `findPrevCreatedAt` returns the position node's createdAt of the
+     * previous element. This returns a position identity suitable for
+     * use as prevCreatedAt in moveAfter.
      */
-    getPrevCreatedAt(createdAt) {
-      let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+    findPrevCreatedAt(createdAt) {
+      const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+      if (!entry) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${createdAt.toIDString()}`
+        );
+      }
+      let node = entry.positionNode;
       do {
         node = node.getPrev();
-      } while (this.dummyHead !== node && node.isRemoved());
-      return node.getValue().getCreatedAt();
+        if (!node.getElementEntry()) {
+          continue;
+        }
+        if (this.dummyHead === node || !node.isRemoved()) {
+          break;
+        }
+      } while (node);
+      return node.getPositionCreatedAt();
+    }
+    /**
+     * `getPrevCreatedAt` returns the position node's createdAt of the
+     * previous element. Delegates to findPrevCreatedAt.
+     */
+    getPrevCreatedAt(createdAt) {
+      return this.findPrevCreatedAt(createdAt);
     }
     /**
      * `delete` deletes the node of the given creation time.
      */
     delete(createdAt, editedAt) {
-      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+      const entry = this.elementMapByCreatedAt.get(createdAt.toIDString());
+      if (!entry) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${createdAt.toIDString()}`
+        );
+      }
+      const node = entry.positionNode;
       const alreadyRemoved = node.isRemoved();
-      if (node.remove(editedAt) && !alreadyRemoved) {
+      if (entry.elem.remove(editedAt) && !alreadyRemoved) {
         this.nodeMapByIndex.splayNode(node);
       }
-      return node.getValue();
+      return entry.elem;
     }
     /**
      * `set` sets the given element at the given creation time.
      */
     set(createdAt, element, executedAt) {
-      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
-      if (!node) {
+      if (!this.elementMapByCreatedAt.has(createdAt.toIDString())) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `cant find the given node: ${createdAt.toIDString()}`
         );
       }
-      this.insertAfter(node.getCreatedAt(), element, executedAt);
+      this.insertAfter(createdAt, element, executedAt);
       return this.delete(createdAt, executedAt);
     }
     /**
@@ -7607,18 +7801,80 @@
       return this.last.getValue();
     }
     /**
-     * `getLastCreatedAt` returns the creation time of last element.
+     * `getLastCreatedAt` returns the position node's createdAt of the
+     * last node in the linked list. This is a position identity
+     * suitable for use as prevCreatedAt.
      */
     getLastCreatedAt() {
-      return this.last.getCreatedAt();
+      return this.last.getPositionCreatedAt();
     }
     /**
-     * `toTestString` returns a String containing the meta data of the node id
-     * for debugging purpose.
+     * `posCreatedAt` returns the createdAt of the position node
+     * currently holding the element. Used to convert element identity
+     * to position identity.
+     */
+    posCreatedAt(elemCreatedAt) {
+      const entry = this.elementMapByCreatedAt.get(elemCreatedAt.toIDString());
+      if (!entry) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${elemCreatedAt.toIDString()}`
+        );
+      }
+      return entry.positionNode.getPositionCreatedAt();
+    }
+    /**
+     * `addDeadPosition` appends a dead position node during snapshot
+     * restoration.
+     */
+    addDeadPosition(posCreatedAt, removedAt) {
+      const node = RGATreeListNode.createBarePosition(posCreatedAt);
+      node.setRemovedAt(removedAt);
+      const prevNode = this.last;
+      RGATreeListNode.insertNodeAfter(prevNode, node);
+      this.last = node;
+      this.nodeMapByIndex.insertAfter(prevNode, node);
+      this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
+    }
+    /**
+     * `addMovedElement` appends an element with explicit position
+     * identity during snapshot restoration.
+     */
+    addMovedElement(elem, posCreatedAt, posMovedAt) {
+      const entry = new ElementEntry(elem);
+      entry.posMovedAt = posMovedAt;
+      const node = RGATreeListNode.createBarePosition(posCreatedAt);
+      node.setElementEntry(entry);
+      entry.positionNode = node;
+      const prevNode = this.last;
+      RGATreeListNode.insertNodeAfter(prevNode, node);
+      this.last = node;
+      this.nodeMapByIndex.insertAfter(prevNode, node);
+      this.nodeMapByCreatedAt.set(posCreatedAt.toIDString(), node);
+      this.elementMapByCreatedAt.set(elem.getCreatedAt().toIDString(), entry);
+    }
+    /**
+     * `allNodes` returns all nodes including dead position nodes.
+     */
+    allNodes() {
+      const nodes = [];
+      let current = this.dummyHead.getNext();
+      while (current) {
+        nodes.push(current);
+        current = current.getNext();
+      }
+      return nodes;
+    }
+    /**
+     * `toTestString` returns a String containing the meta data of the
+     * node id for debugging purpose.
      */
     toTestString() {
       const json = [];
       for (const node of this) {
+        if (!node.getElementEntry()) {
+          continue;
+        }
         const elem = `${node.getCreatedAt().toIDString()}:${node.getValue().toJSON()}`;
         if (node.isRemoved()) {
           json.push(`{${elem}}`);
@@ -7675,10 +7931,11 @@
       this.elements.insertAfter(prevCreatedAt, value, executedAt);
     }
     /**
-     * `moveAfter` moves the given `createdAt` element after the `prevCreatedAt`.
+     * `moveAfter` moves the given `createdAt` element after the
+     * `prevCreatedAt`. Returns the dead position node for GC.
      */
     moveAfter(prevCreatedAt, createdAt, executedAt) {
-      this.elements.moveAfter(prevCreatedAt, createdAt, executedAt);
+      return this.elements.moveAfter(prevCreatedAt, createdAt, executedAt);
     }
     /**
      * `get` returns the element of the given index.
@@ -7707,11 +7964,20 @@
       return this.elements.getLast();
     }
     /**
-     * `getPrevCreatedAt` returns the creation time of the previous node.
+     * `getPrevCreatedAt` returns the creation time of the previous
+     * node.
      */
     getPrevCreatedAt(createdAt) {
       return this.elements.getPrevCreatedAt(createdAt);
     }
+    /**
+     * `posCreatedAt` returns the createdAt of the position node
+     * currently holding the element. Used to convert element identity
+     * to position identity for moves.
+     */
+    posCreatedAt(elemCreatedAt) {
+      return this.elements.posCreatedAt(elemCreatedAt);
+    }
     /**
      * `delete` deletes the element of the given creation time.
      */
@@ -7725,7 +7991,8 @@
       return this.elements.deleteByIndex(index, editedAt);
     }
     /**
-     * `set` sets the given element at the given position of the creation time.
+     * `set` sets the given element at the given position of the
+     * creation time.
      */
     set(createdAt, value, executedAt) {
       return this.elements.set(createdAt, value, executedAt);
@@ -7743,18 +8010,19 @@
       return this.elements.length;
     }
     /**
-     * `[Symbol.iterator]` returns an iterator for the elements in this array.
+     * `[Symbol.iterator]` returns an iterator for the elements in
+     * this array.
      */
     *[Symbol.iterator]() {
       for (const node of this.elements) {
-        if (!node.isRemoved()) {
+        if (node.getElementEntry() && !node.isRemoved()) {
           yield node.getValue();
         }
       }
     }
     /**
-     * `toTestString` returns a String containing the meta data of this value
-     * for debugging purpose.
+     * `toTestString` returns a String containing the meta data of
+     * this value for debugging purpose.
      */
     toTestString() {
       return this.elements.toTestString();
@@ -7764,6 +8032,9 @@
      */
     getDescendants(callback) {
       for (const node of this.elements) {
+        if (!node.getElementEntry()) {
+          continue;
+        }
         const element = node.getValue();
         if (callback(element, this)) {
           return;
@@ -7825,21 +8096,52 @@
       return this.toJSON();
     }
     /**
-     * `getElements` returns an array of elements contained in this RGATreeList.
+     * `getElements` returns the underlying RGATreeList.
      */
     getElements() {
       return this.elements;
     }
+    /**
+     * `getRGATreeList` returns the underlying RGATreeList (GCParent
+     * for dead positions).
+     */
+    getRGATreeList() {
+      return this.elements;
+    }
+    /**
+     * `getAllRGANodes` returns all RGA nodes including dead position
+     * nodes.
+     */
+    getAllRGANodes() {
+      return this.elements.allNodes();
+    }
     /**
      * `deepcopy` copies itself deeply.
      */
     deepcopy() {
       const clone = CRDTArray.create(this.getCreatedAt());
       for (const node of this.elements) {
-        clone.elements.insertAfter(
-          clone.getLastCreatedAt(),
-          node.getValue().deepcopy()
-        );
+        if (!node.getElementEntry()) {
+          const removedAt = node.getRemovedAt();
+          if (removedAt) {
+            clone.elements.addDeadPosition(
+              node.getPositionCreatedAt(),
+              removedAt
+            );
+          }
+          continue;
+        }
+        const value = node.getValue().deepcopy();
+        const posMovedAt = node.getPositionMovedAt();
+        if (posMovedAt) {
+          clone.elements.addMovedElement(
+            value,
+            node.getPositionCreatedAt(),
+            posMovedAt
+          );
+        } else {
+          clone.elements.insertAfter(clone.getLastCreatedAt(), value);
+        }
       }
       clone.setRemovedAt(this.getRemovedAt());
       clone.setMovedAt(this.getMovedAt());
@@ -8096,6 +8398,9 @@
       if (removed) {
         root.registerRemovedElement(removed);
       }
+      if (value.getRemovedAt()) {
+        root.registerRemovedElement(value);
+      }
       return {
         opInfos: [
           {
@@ -8188,7 +8493,17 @@
       const array = parentObject;
       const reverseOp = this.toReverseOperation(array);
       const previousIndex = Number(array.subPathOf(this.createdAt));
-      array.moveAfter(this.prevCreatedAt, this.createdAt, this.getExecutedAt());
+      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: [
@@ -8211,7 +8526,8 @@
       );
     }
     /**
-     * `getEffectedCreatedAt` returns the creation time of the effected element.
+     * `getEffectedCreatedAt` returns the creation time of the
+     * effected element.
      */
     getEffectedCreatedAt() {
       return this.createdAt;
@@ -8223,7 +8539,8 @@
       return `${this.getParentCreatedAt().toTestString()}.MOVE`;
     }
     /**
-     * `getPrevCreatedAt` returns the creation time of previous element.
+     * `getPrevCreatedAt` returns the creation time of previous
+     * element.
      */
     getPrevCreatedAt() {
       return this.prevCreatedAt;
@@ -8235,7 +8552,8 @@
       return this.createdAt;
     }
     /**
-     * `setPrevCreatedAt` sets the creation time of the previous element.
+     * `setPrevCreatedAt` sets the creation time of the previous
+     * element.
      */
     setPrevCreatedAt(createdAt) {
       this.prevCreatedAt = createdAt;
@@ -10816,6 +11134,32 @@
         }
         actualRight.push(child);
       }
+      if (versionVector) {
+        const movedToLeft = [];
+        const remaining = [];
+        let boundaryReached = false;
+        for (const child of actualRight) {
+          if (!boundaryReached) {
+            if (child.insPrevID !== void 0 && !child.isText) {
+              remaining.push(child);
+              continue;
+            }
+            const actorID = child.id.getCreatedAt().getActorID();
+            const knownLamport = versionVector.get(actorID);
+            if (knownLamport === void 0 || knownLamport < child.id.getCreatedAt().getLamport()) {
+              movedToLeft.push(child);
+              continue;
+            }
+          }
+          boundaryReached = true;
+          remaining.push(child);
+        }
+        if (movedToLeft.length > 0) {
+          left.push(...movedToLeft);
+          actualRight.length = 0;
+          actualRight.push(...remaining);
+        }
+      }
       this._children = left;
       clone._children = actualRight;
       this.visibleSize = this._children.reduce(
@@ -11579,7 +11923,7 @@
         CRDTTreeNodeID.of(issueTimeTicket(), 0),
         this.type,
         void 0,
-        void 0,
+        this.attrs?.deepcopy(),
         this.removedAt
       );
     }
@@ -11592,8 +11936,14 @@
         split.insPrevID = this.id;
         if (this.insNextID) {
           const insNext = tree.findFloorNode(this.insNextID);
-          insNext.insPrevID = split.id;
           split.insNextID = this.insNextID;
+          if (insNext) {
+            insNext.insPrevID = split.id;
+            if (!this.isText && insNext.parent && !insNext.isRemoved && insNext.parent !== split.parent && split.allChildren.length === 0) {
+              split.parent.detachChild(split);
+              insNext.parent.insertBefore(split, insNext);
+            }
+          }
         }
         this.insNextID = split.id;
         tree.registerNode(split);
@@ -11817,7 +12167,7 @@
      * given node, advancing past element-type split siblings that the editing
      * client did not know about (not in versionVector).
      */
-    advancePastUnknownSplitSiblings(node, versionVector) {
+    advancePastUnknownSplitSiblings(node, versionVector, relaxParentCheck = false, skipActorID) {
       if (!versionVector || !node) {
         return node;
       }
@@ -11827,10 +12177,13 @@
         if (!next || next.isText) {
           break;
         }
-        if (next.parent !== current.parent) {
+        if (!relaxParentCheck && next.parent !== current.parent) {
           break;
         }
         const actorID = next.id.getCreatedAt().getActorID();
+        if (skipActorID !== void 0 && actorID === skipActorID) {
+          break;
+        }
         const knownLamport = versionVector.get(actorID);
         if (knownLamport !== void 0 && knownLamport >= next.id.getCreatedAt().getLamport()) {
           break;
@@ -11999,6 +12352,53 @@
                 addDataSizes(diff, curr.getDataSize());
               }
             }
+            if (tokenType === TokenType.Start && versionVector !== void 0) {
+              let current = node;
+              while (current.insNextID) {
+                const next = this.findFloorNode(current.insNextID);
+                if (!next || next.isText) {
+                  break;
+                }
+                if (ticketKnown(versionVector, next.id.getCreatedAt())) {
+                  break;
+                }
+                const siblingPairs = next.setAttrs(attributes, editedAt);
+                const siblingAffectedAttrs = siblingPairs.reduce(
+                  (acc, [, curr]) => {
+                    if (curr) {
+                      acc[curr.getKey()] = attrs[curr.getKey()];
+                    }
+                    return acc;
+                  },
+                  {}
+                );
+                if (Object.keys(siblingAffectedAttrs).length > 0) {
+                  const parentOfNext = next.parent;
+                  const previousNext = next.prevSibling || parentOfNext;
+                  changes.push({
+                    type: "style",
+                    from: this.toIndex(parentOfNext, previousNext),
+                    to: this.toIndex(next, next),
+                    fromPath: this.toPath(parentOfNext, previousNext),
+                    toPath: this.toPath(next, next),
+                    actor: editedAt.getActorID(),
+                    value: siblingAffectedAttrs
+                  });
+                }
+                for (const [prev] of siblingPairs) {
+                  if (prev) {
+                    pairs.push({ parent: next, child: prev });
+                  }
+                }
+                for (const [key] of Object.entries(attrs)) {
+                  const curr = next.attrs?.getNodeMapByKey().get(key);
+                  if (curr !== void 0) {
+                    addDataSizes(diff, curr.getDataSize());
+                  }
+                }
+                current = next;
+              }
+            }
           }
         }
       );
@@ -12065,6 +12465,43 @@
               toPath: this.toPath(node, node),
               value: attributesToRemove
             });
+            if (tokenType === TokenType.Start && versionVector !== void 0) {
+              let current = node;
+              while (current.insNextID) {
+                const next = this.findFloorNode(current.insNextID);
+                if (!next || next.isText) {
+                  break;
+                }
+                if (ticketKnown(versionVector, next.id.getCreatedAt())) {
+                  break;
+                }
+                if (!next.attrs) {
+                  next.attrs = new RHT();
+                }
+                let removedAny = false;
+                for (const value of attributesToRemove) {
+                  const nodesTobeRemoved = next.attrs.remove(value, editedAt);
+                  removedAny = removedAny || nodesTobeRemoved.length > 0;
+                  for (const rhtNode of nodesTobeRemoved) {
+                    pairs.push({ parent: next, child: rhtNode });
+                  }
+                }
+                if (removedAny) {
+                  const parentOfNext = next.parent;
+                  const previousNext = next.prevSibling || parentOfNext;
+                  changes.push({
+                    actor: editedAt.getActorID(),
+                    type: "removeStyle",
+                    from: this.toIndex(parentOfNext, previousNext),
+                    to: this.toIndex(next, next),
+                    fromPath: this.toPath(parentOfNext, previousNext),
+                    toPath: this.toPath(next, next),
+                    value: attributesToRemove
+                  });
+                }
+                current = next;
+              }
+            }
           }
         }
       );
@@ -12087,6 +12524,23 @@
       addDataSizes(diff, diffTo, diffFrom);
       const fromLeft = fromLeftRaw !== fromParent ? this.advancePastUnknownSplitSiblings(fromLeftRaw, versionVector) : fromLeftRaw;
       const toLeft = toLeftRaw !== toParent ? this.advancePastUnknownSplitSiblings(toLeftRaw, versionVector) : toLeftRaw;
+      let collectFromParent = fromParent;
+      let collectFromLeft = fromLeft;
+      if (fromLeft !== fromParent && fromParent !== toParent) {
+        let current = fromLeft;
+        while (current.insNextID) {
+          const next = this.findFloorNode(current.insNextID);
+          if (!next || next.isText) {
+            break;
+          }
+          if (next.parent && next.parent === toParent) {
+            collectFromLeft = next;
+            collectFromParent = toParent;
+            break;
+          }
+          current = next;
+        }
+      }
       const fromIdx = this.toIndex(fromParent, fromLeft);
       const fromPath = this.toPath(fromParent, fromLeft);
       const nodesToBeRemoved = [];
@@ -12095,8 +12549,8 @@
       const toBeMergedNodes = [];
       const preTombstoned = /* @__PURE__ */ new Set();
       this.traverseInPosRange(
-        fromParent,
-        fromLeft,
+        collectFromParent,
+        collectFromLeft,
         toParent,
         toLeft,
         ([node, tokenType], ended) => {
@@ -12200,9 +12654,20 @@
         let parent = fromParent;
         let left = fromLeft;
         while (splitCount < splitLevel) {
+          if (left !== parent) {
+            left = this.advancePastUnknownSplitSiblings(
+              left,
+              versionVector,
+              true,
+              editedAt.getActorID()
+            );
+            if (left.parent && left.parent !== parent) {
+              parent = left.parent;
+            }
+          }
           parent.split(
             this,
-            parent.findOffset(left, true) + 1,
+            left !== parent ? parent.findOffset(left, true) + 1 : 0,
             issueTimeTicket,
             versionVector
           );
@@ -12809,10 +13274,10 @@
       );
       this.lastToIdx = preEditFromIdx + removedSize;
       let reverseOp;
-      const isPureL1Split = this.splitLevel === 1 && !this.contents?.length && removedNodes.length === 0;
+      const isPureSplit = this.splitLevel > 0 && !this.contents?.length && removedNodes.length === 0;
       if (this.splitLevel === 0) {
         reverseOp = this.toReverseOperation(tree, removedNodes, preEditFromIdx);
-      } else if (isPureL1Split) {
+      } else if (isPureSplit) {
         reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
       }
       root.acc(diff);
@@ -14823,14 +15288,26 @@
     }
     return pbRHTNodes;
   }
-  function toRGANodes(rgaTreeList) {
+  function toRGANodes(arr) {
     const pbRGANodes = [];
-    for (const rgaTreeListNode of rgaTreeList) {
-      pbRGANodes.push(
-        create(RGANodeSchema, {
-          element: toElement(rgaTreeListNode.getValue())
-        })
-      );
+    for (const rgaNode of arr.getAllRGANodes()) {
+      if (!rgaNode.getElementEntry()) {
+        pbRGANodes.push(
+          create(RGANodeSchema, {
+            positionCreatedAt: toTimeTicket(rgaNode.getPositionCreatedAt()),
+            positionRemovedAt: toTimeTicket(rgaNode.getRemovedAt())
+          })
+        );
+        continue;
+      }
+      const pbNode = create(RGANodeSchema, {
+        element: toElement(rgaNode.getValue())
+      });
+      if (rgaNode.getPositionMovedAt()) {
+        pbNode.positionMovedAt = toTimeTicket(rgaNode.getPositionMovedAt());
+        pbNode.positionCreatedAt = toTimeTicket(rgaNode.getPositionCreatedAt());
+      }
+      pbRGANodes.push(pbNode);
     }
     return pbRGANodes;
   }
@@ -14930,7 +15407,7 @@
       body: {
         case: "jsonArray",
         value: create(JSONElement_JSONArraySchema, {
-          nodes: toRGANodes(arr.getElements()),
+          nodes: toRGANodes(arr),
           createdAt: toTimeTicket(arr.getCreatedAt()),
           movedAt: toTimeTicket(arr.getMovedAt()),
           removedAt: toTimeTicket(arr.getRemovedAt())
@@ -15468,7 +15945,32 @@
   function fromArray(pbArray) {
     const rgaTreeList = new RGATreeList();
     for (const pbRGANode of pbArray.nodes) {
-      rgaTreeList.insert(fromElement(pbRGANode.element));
+      if (!pbRGANode.element) {
+        if (!pbRGANode.positionCreatedAt || !pbRGANode.positionRemovedAt) {
+          throw new YorkieError(
+            Code.ErrInvalidArgument,
+            "dead RGA position node missing position timestamps"
+          );
+        }
+        const posCreatedAt = fromTimeTicket(pbRGANode.positionCreatedAt);
+        const posRemovedAt = fromTimeTicket(pbRGANode.positionRemovedAt);
+        rgaTreeList.addDeadPosition(posCreatedAt, posRemovedAt);
+        continue;
+      }
+      const elem = fromElement(pbRGANode.element);
+      const posMovedAt = fromTimeTicket(pbRGANode.positionMovedAt);
+      if (posMovedAt) {
+        if (!pbRGANode.positionCreatedAt) {
+          throw new YorkieError(
+            Code.ErrInvalidArgument,
+            "moved RGA node missing position_created_at"
+          );
+        }
+        const posCreatedAt = fromTimeTicket(pbRGANode.positionCreatedAt);
+        rgaTreeList.addMovedElement(elem, posCreatedAt, posMovedAt);
+      } else {
+        rgaTreeList.insert(elem);
+      }
     }
     const arr = new CRDTArray(fromTimeTicket(pbArray.createdAt), rgaTreeList);
     arr.setMovedAt(fromTimeTicket(pbArray.movedAt));
@@ -16256,10 +16758,16 @@
             };
           } else if (method === "insertAfter") {
             return (prevID, value) => {
+              let posCreatedAt;
+              try {
+                posCreatedAt = target.posCreatedAt(prevID);
+              } catch {
+                posCreatedAt = prevID;
+              }
               const inserted = ArrayProxy.insertAfterInternal(
                 context,
                 target,
-                prevID,
+                posCreatedAt,
                 value
               );
               return toWrappedElement(context, inserted);
@@ -16444,7 +16952,7 @@
     static moveBeforeInternal(context, target, nextCreatedAt, createdAt) {
       const ticket = context.issueTimeTicket();
       const prevCreatedAt = target.getPrevCreatedAt(nextCreatedAt);
-      target.moveAfter(prevCreatedAt, createdAt, ticket);
+      const deadNode = target.moveAfter(prevCreatedAt, createdAt, ticket);
       context.push(
         MoveOperation.create(
           target.getCreatedAt(),
@@ -16453,26 +16961,45 @@
           ticket
         )
       );
+      if (deadNode) {
+        context.registerGCPair({
+          parent: target.getRGATreeList(),
+          child: deadNode
+        });
+      }
     }
     /**
      * `moveAfterInternal` moves the given `createdAt` element
-     * after the specific element.
+     * after the specific element. Converts element identity to
+     * position identity for the prevCreatedAt.
      */
     static moveAfterInternal(context, target, prevCreatedAt, createdAt) {
       const ticket = context.issueTimeTicket();
+      let posCreatedAt;
+      try {
+        posCreatedAt = target.posCreatedAt(prevCreatedAt);
+      } catch {
+        posCreatedAt = prevCreatedAt;
+      }
+      const deadNode = target.moveAfter(posCreatedAt, createdAt, ticket);
       context.push(
         MoveOperation.create(
           target.getCreatedAt(),
-          prevCreatedAt,
+          posCreatedAt,
           createdAt,
           ticket
         )
       );
-      target.moveAfter(prevCreatedAt, createdAt, ticket);
+      if (deadNode) {
+        context.registerGCPair({
+          parent: target.getRGATreeList(),
+          child: deadNode
+        });
+      }
     }
     /**
-     * `moveAfterByIndexInternal` moves the given element to its new position
-     * after the given previous element.
+     * `moveAfterByIndexInternal` moves the given element to its new
+     * position after the given previous element.
      */
     static moveAfterByIndexInternal(context, target, prevIndex, targetIndex) {
       const prevElem = target.get(prevIndex);
@@ -16503,7 +17030,7 @@
     static moveFrontInternal(context, target, createdAt) {
       const ticket = context.issueTimeTicket();
       const head = target.getHead();
-      target.moveAfter(head.getCreatedAt(), createdAt, ticket);
+      const deadNode = target.moveAfter(head.getCreatedAt(), createdAt, ticket);
       context.push(
         MoveOperation.create(
           target.getCreatedAt(),
@@ -16512,6 +17039,12 @@
           ticket
         )
       );
+      if (deadNode) {
+        context.registerGCPair({
+          parent: target.getRGATreeList(),
+          child: deadNode
+        });
+      }
     }
     /**
      * `moveLastInternal` moves the given `createdAt` element
@@ -16520,13 +17053,20 @@
     static moveLastInternal(context, target, createdAt) {
       const ticket = context.issueTimeTicket();
       const last = target.getLastCreatedAt();
-      target.moveAfter(last, createdAt, ticket);
+      const deadNode = target.moveAfter(last, createdAt, ticket);
       context.push(
         MoveOperation.create(target.getCreatedAt(), last, createdAt, ticket)
       );
+      if (deadNode) {
+        context.registerGCPair({
+          parent: target.getRGATreeList(),
+          child: deadNode
+        });
+      }
     }
     /**
-     * `insertAfterInternal` inserts the value after the previously created element.
+     * `insertAfterInternal` inserts the value after the previously
+     * created element.
      */
     static insertAfterInternal(context, target, prevCreatedAt, value) {
       const createdAt = context.issueTimeTicket();
@@ -16554,12 +17094,13 @@
           `index out of bounds: ${index}`
         );
       }
-      ArrayProxy.insertAfterInternal(
-        context,
-        target,
-        prevElem.getCreatedAt(),
-        value
-      );
+      let posCreatedAt;
+      try {
+        posCreatedAt = target.posCreatedAt(prevElem.getCreatedAt());
+      } catch {
+        posCreatedAt = prevElem.getCreatedAt();
+      }
+      ArrayProxy.insertAfterInternal(context, target, posCreatedAt, value);
       return target;
     }
     /**
@@ -16658,7 +17199,17 @@
         }
       }
       if (items) {
-        let previousID = from === 0 ? target.getHead().getID() : target.get(from - 1).getID();
+        let previousID;
+        if (from === 0) {
+          previousID = target.getHead().getID();
+        } else {
+          const elemID = target.get(from - 1).getID();
+          try {
+            previousID = target.posCreatedAt(elemID);
+          } catch {
+            previousID = elemID;
+          }
+        }
         for (const item of items) {
           const newElem = ArrayProxy.insertAfterInternal(
             context,
@@ -18008,6 +18559,16 @@
             this.registerGCPair(pair);
           }
         }
+        if (elem instanceof CRDTArray) {
+          for (const node of elem.getAllRGANodes()) {
+            if (!node.getElementEntry() && node.getRemovedAt()) {
+              this.registerGCPair({
+                parent: elem.getRGATreeList(),
+                child: node
+              });
+            }
+          }
+        }
         return false;
       });
     }
@@ -19094,6 +19655,11 @@
         if (logger.isEnabled(LogLevel.Trivial)) {
           logger.trivial(`trying to update a local change: ${this.toJSON()}`);
         }
+        const prev = {
+          hadPresence: this.presences.has(actorID),
+          wasOnline: this.status === "attached",
+          presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+        };
         const change = ctx.toChange();
         const { opInfos, reverseOps } = change.execute(
           this.root,
@@ -19139,14 +19705,14 @@
           });
         }
         if (change.hasPresenceChange()) {
-          event.push({
-            type: "presence-changed",
-            source: OpSource.Local,
-            value: {
-              clientID: actorID,
-              presence: this.getPresence(actorID)
-            }
-          });
+          const presenceEvent = this.reconcilePresence(
+            actorID,
+            prev,
+            OpSource.Local
+          );
+          if (presenceEvent) {
+            event.push(presenceEvent);
+          }
         }
         this.publish(event);
         if (logger.isEnabled(LogLevel.Trivial)) {
@@ -19630,41 +20196,11 @@
       change.execute(this.clone.root, this.clone.presences, source);
       const events = [];
       const actorID = change.getID().getActorID();
-      if (change.hasPresenceChange() && this.onlineClients.has(actorID)) {
-        const presenceChange = change.getPresenceChange();
-        switch (presenceChange.type) {
-          case PresenceChangeType.Put:
-            events.push(
-              this.presences.has(actorID) ? {
-                type: "presence-changed",
-                source,
-                value: {
-                  clientID: actorID,
-                  presence: presenceChange.presence
-                }
-              } : {
-                type: "watched",
-                source: OpSource.Remote,
-                value: {
-                  clientID: actorID,
-                  presence: presenceChange.presence
-                }
-              }
-            );
-            break;
-          case PresenceChangeType.Clear:
-            events.push({
-              type: "unwatched",
-              source: OpSource.Remote,
-              value: {
-                clientID: actorID,
-                presence: this.getPresence(actorID)
-              }
-            });
-            this.removeOnlineClient(actorID);
-            break;
-        }
-      }
+      const prev = change.hasPresenceChange() ? {
+        hadPresence: this.presences.has(actorID),
+        wasOnline: this.onlineClients.has(actorID),
+        presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+      } : void 0;
       const { opInfos, operations } = change.execute(
         this.root,
         this.presences,
@@ -19719,6 +20255,16 @@
           }
         );
       }
+      if (prev && change.hasPresenceChange()) {
+        const presenceChange = change.getPresenceChange();
+        if (presenceChange.type === PresenceChangeType.Clear) {
+          this.removeOnlineClient(actorID);
+        }
+        const presenceEvent = this.reconcilePresence(actorID, prev, source);
+        if (presenceEvent) {
+          events.push(presenceEvent);
+        }
+      }
       if (events.length) {
         this.publish(events);
       }
@@ -19747,46 +20293,43 @@
      * `applyDocEvent` applies the given doc event into this document.
      */
     applyDocEvent(type, publisher) {
-      const events = [];
+      const prev = {
+        hadPresence: this.presences.has(publisher),
+        wasOnline: this.onlineClients.has(publisher),
+        presence: this.presences.has(publisher) ? deepcopy(this.presences.get(publisher)) : void 0
+      };
       if (type === DocEventType$1.DOCUMENT_WATCHED) {
         if (this.onlineClients.has(publisher) && this.hasPresence(publisher)) {
           return;
         }
         this.addOnlineClient(publisher);
-        if (this.hasPresence(publisher)) {
-          events.push({
-            type: "watched",
-            source: OpSource.Remote,
-            value: {
-              clientID: publisher,
-              presence: this.getPresence(publisher)
-            }
-          });
-        }
       } else if (type === DocEventType$1.DOCUMENT_UNWATCHED) {
-        const presence = this.getPresence(publisher);
         this.removeOnlineClient(publisher);
         this.presences.delete(publisher);
-        if (presence) {
-          events.push({
-            type: "unwatched",
-            source: OpSource.Remote,
-            value: { clientID: publisher, presence }
-          });
-        }
       }
-      if (events.length) {
-        this.publish(events);
+      const event = this.reconcilePresence(publisher, prev, OpSource.Remote);
+      if (event) {
+        this.publish([event]);
       }
     }
     /**
      * `applyStatus` applies the document status into this document.
      */
     applyStatus(status) {
+      const actorID = this.changeID.getActorID();
+      const prev = {
+        hadPresence: this.presences.has(actorID),
+        wasOnline: this.status === "attached",
+        presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+      };
       this.status = status;
       if (status === "detached") {
         this.setActor(InitialActorID);
       }
+      const event = this.reconcilePresence(actorID, prev, OpSource.Local);
+      if (event) {
+        this.publish([event]);
+      }
       this.publish([
         {
           source: status === "removed" ? OpSource.Remote : OpSource.Local,
@@ -19886,6 +20429,57 @@
     removeOnlineClient(clientID) {
       this.onlineClients.delete(clientID);
     }
+    /**
+     * `reconcilePresence` compares the previous and current state of a client's
+     * presence/online status and returns the appropriate event to emit.
+     *
+     * For remote clients, "online" means the client is in onlineClients.
+     * For self, "online" means the document status is Attached.
+     *
+     * State transition table:
+     *   (!hadP || !wasOn) → (hasP && isOn)  : watched (remote) or presence-changed (self)
+     *   (hadP && wasOn)   → (hasP && isOn)  : presence-changed
+     *   (hadP && wasOn)   → (!hasP || !isOn): unwatched (remote only)
+     *   otherwise                           : no event (waiting)
+     */
+    reconcilePresence(actorID, prev, source) {
+      const isSelf = actorID === this.changeID.getActorID();
+      const hasPresence = this.presences.has(actorID);
+      const isOnline = isSelf ? this.status === "attached" : this.onlineClients.has(actorID);
+      if (!hasPresence || !isOnline) {
+        if (prev.hadPresence && prev.wasOnline && !isSelf) {
+          return {
+            type: "unwatched",
+            source: OpSource.Remote,
+            value: {
+              clientID: actorID,
+              presence: prev.presence
+            }
+          };
+        }
+        return void 0;
+      }
+      const presence = deepcopy(this.presences.get(actorID));
+      if (!prev.hadPresence || !prev.wasOnline) {
+        if (isSelf) {
+          return {
+            type: "presence-changed",
+            source,
+            value: { clientID: actorID, presence }
+          };
+        }
+        return {
+          type: "watched",
+          source: OpSource.Remote,
+          value: { clientID: actorID, presence }
+        };
+      }
+      return {
+        type: "presence-changed",
+        source,
+        value: { clientID: actorID, presence }
+      };
+    }
     /**
      * `hasPresence` returns whether the given clientID has a presence or not.
      */
@@ -20047,18 +20641,24 @@
         const ticket = ctx.issueTimeTicket();
         op.setExecutedAt(ticket);
         if (op instanceof ArraySetOperation) {
-          const prev = op.getCreatedAt();
+          const prev2 = op.getCreatedAt();
           op.getValue().setCreatedAt(ticket);
-          this.internalHistory.reconcileCreatedAt(prev, ticket);
+          this.internalHistory.reconcileCreatedAt(prev2, ticket);
         } else if (op instanceof AddOperation) {
-          const prev = op.getValue().getCreatedAt();
+          const prev2 = op.getValue().getCreatedAt();
           op.getValue().setCreatedAt(ticket);
-          this.internalHistory.reconcileCreatedAt(prev, ticket);
+          this.internalHistory.reconcileCreatedAt(prev2, ticket);
         }
         ctx.push(op);
       }
       const change = ctx.toChange();
       change.execute(this.clone.root, this.clone.presences, OpSource.UndoRedo);
+      const actorID = this.changeID.getActorID();
+      const prev = {
+        hadPresence: this.presences.has(actorID),
+        wasOnline: this.status === "attached",
+        presence: this.presences.has(actorID) ? deepcopy(this.presences.get(actorID)) : void 0
+      };
       const { opInfos, reverseOps } = change.execute(
         this.root,
         this.presences,
@@ -20080,7 +20680,6 @@
       }
       this.localChanges.push(change);
       this.changeID = ctx.getNextID();
-      const actorID = this.changeID.getActorID();
       const events = [];
       if (opInfos.length) {
         events.push({
@@ -20097,14 +20696,14 @@
         });
       }
       if (change.hasPresenceChange()) {
-        events.push({
-          type: "presence-changed",
-          source: OpSource.UndoRedo,
-          value: {
-            clientID: actorID,
-            presence: this.getPresence(actorID)
-          }
-        });
+        const presenceEvent = this.reconcilePresence(
+          actorID,
+          prev,
+          OpSource.UndoRedo
+        );
+        if (presenceEvent) {
+          events.push(presenceEvent);
+        }
       }
       this.publish(events);
     }
@@ -20120,6 +20719,8 @@
     watchStream;
     watchLoopTimerID;
     watchAbortController;
+    syncPromise;
+    _detaching = false;
     constructor(reconnectStreamDelay, resource, resourceID, syncMode) {
       this.reconnectStreamDelay = reconnectStreamDelay;
       this.resource = resource;
@@ -20195,6 +20796,49 @@
       };
       await doLoop();
     }
+    /**
+     * `markDetaching` marks this attachment as being in the process of detaching.
+     * Once marked, the sync loop will skip this attachment.
+     */
+    markDetaching() {
+      this._detaching = true;
+    }
+    /**
+     * `isDetaching` returns whether this attachment is being detached.
+     */
+    isDetaching() {
+      return this._detaching;
+    }
+    /**
+     * `resetDetaching` resets the detaching flag so the attachment can resume
+     * syncing. Used when a detach RPC fails and the document remains attached.
+     */
+    resetDetaching() {
+      this._detaching = false;
+    }
+    /**
+     * `setSyncPromise` sets the in-progress sync promise for this attachment.
+     */
+    setSyncPromise(promise) {
+      this.syncPromise = promise;
+    }
+    /**
+     * `clearSyncPromise` clears the in-progress sync promise.
+     */
+    clearSyncPromise() {
+      this.syncPromise = void 0;
+    }
+    /**
+     * `waitForSyncComplete` waits for any in-progress sync to complete.
+     */
+    async waitForSyncComplete() {
+      if (this.syncPromise) {
+        try {
+          await this.syncPromise;
+        } catch {
+        }
+      }
+    }
     /**
      * `cancelWatchStream` cancels the watch stream.
      */
@@ -20229,7 +20873,7 @@
     };
   }
   const name$1 = "@yorkie-js/sdk";
-  const version$1 = "0.7.5";
+  const version$1 = "0.7.7";
   const pkg$1 = {
     name: name$1,
     version: version$1
@@ -20544,6 +21188,7 @@
     taskQueue;
     processing = false;
     keepalive = false;
+    deactivating = false;
     /**
      * @param rpcAddr - the address of the RPC server.
      * @param opts - the options of the client.
@@ -20613,6 +21258,7 @@
           );
           this.id = res.clientId;
           this.status = "activated";
+          this.deactivating = false;
           this.runSyncLoop();
           logger.info(`[AC] c:"${this.getKey()}" activated, id:"${this.id}"`);
           if (typeof window !== "undefined") {
@@ -20641,6 +21287,7 @@
       if (this.status === "deactivated") {
         return Promise.resolve();
       }
+      this.deactivating = true;
       const task = async () => {
         try {
           await this.rpcClient.deactivateClient(
@@ -20654,6 +21301,7 @@
           logger.info(`[DC] c"${this.getKey()}" deactivated`);
         } catch (err) {
           logger.error(`[DC] c:"${this.getKey()}" err :`, err);
+          this.deactivating = false;
           await this.handleConnectError(err);
           throw err;
         }
@@ -20794,8 +21442,10 @@
         );
       }
       doc.update((_, p) => p.clear());
+      attachment.markDetaching();
       const task = async () => {
         try {
+          await attachment.waitForSyncComplete();
           const res = await this.rpcClient.detachDocument(
             {
               clientId: this.id,
@@ -20814,6 +21464,7 @@
           return doc;
         } catch (err) {
           logger.error(`[DD] c:"${this.getKey()}" err :`, err);
+          attachment.resetDetaching();
           await this.handleConnectError(err);
           throw err;
         }
@@ -21380,7 +22031,7 @@
      */
     runSyncLoop() {
       const doLoop = async () => {
-        if (!this.isActive()) {
+        if (!this.isActive() || this.deactivating) {
           logger.debug(`[SL] c:"${this.getKey()}" exit sync loop`);
           this.conditions[
             "SyncLoop"
@@ -21392,43 +22043,62 @@
           await this.enqueueTask(async () => {
             const syncs = [];
             for (const [, attachment] of this.attachmentMap) {
+              if (this.deactivating) {
+                break;
+              }
               if (!attachment.needSync(this.channelHeartbeatInterval)) {
                 continue;
               }
+              if (attachment.isDetaching()) {
+                continue;
+              }
               if (attachment.changeEventReceived !== void 0) {
                 attachment.changeEventReceived = false;
               }
-              syncs.push(
-                this.syncInternal(attachment, attachment.syncMode).catch((e) => {
-                  if (isErrorCode(e, Code.ErrUnauthenticated)) {
-                    attachment.resource.publish([
-                      {
-                        type: DocEventType.AuthError,
-                        value: {
-                          reason: errorMetadataOf(e).reason,
-                          method: "PushPull"
-                        }
+              const syncPromise = this.syncInternal(
+                attachment,
+                attachment.syncMode
+              ).then(() => {
+              }).catch((e) => {
+                if (isErrorCode(e, Code.ErrUnauthenticated)) {
+                  attachment.resource.publish([
+                    {
+                      type: DocEventType.AuthError,
+                      value: {
+                        reason: errorMetadataOf(e).reason,
+                        method: "PushPull"
                       }
-                    ]);
-                  }
-                  if (isErrorCode(e, Code.ErrEpochMismatch)) {
-                    attachment.resource.publish([
-                      {
-                        type: DocEventType.EpochMismatch,
-                        value: {
-                          method: "PushPull"
-                        }
+                    }
+                  ]);
+                }
+                if (isErrorCode(e, Code.ErrEpochMismatch)) {
+                  attachment.resource.publish([
+                    {
+                      type: DocEventType.EpochMismatch,
+                      value: {
+                        method: "PushPull"
                       }
-                    ]);
-                  }
-                  throw e;
-                })
-              );
+                    }
+                  ]);
+                }
+                throw e;
+              }).finally(() => {
+                attachment.clearSyncPromise();
+              });
+              attachment.setSyncPromise(syncPromise);
+              syncs.push(syncPromise);
             }
             await Promise.all(syncs);
             setTimeout(doLoop, this.syncLoopDuration);
           });
         } catch (err) {
+          if (this.deactivating) {
+            this.conditions[
+              "SyncLoop"
+              /* SyncLoop */
+            ] = false;
+            return;
+          }
           logger.error(`[SL] c:"${this.getKey()}" sync failed:`, err);
           if (await this.handleConnectError(err)) {
             setTimeout(doLoop, this.retrySyncLoopDelay);
@@ -21909,8 +22579,11 @@
   function isCounter(value) {
     return typeof value === "object" && value !== null && value.type === "Counter" && typeof value.value === "object";
   }
+  function isDedupCounter(value) {
+    return typeof value === "object" && value !== null && value.type === "DedupCounter" && typeof value.value === "object" && typeof value.registers === "string";
+  }
   function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value) && !isDedupCounter(value);
   }
   function parse(yson) {
     try {
@@ -21926,6 +22599,12 @@
   }
   function preprocessYSON(yson) {
     let result = yson;
+    result = result.replace(
+      /DedupCounter\(Int\((-?\d+)\),"([^"]+)"\)/g,
+      (_, value, registers) => {
+        return `{"__yson_type":"DedupCounter","__yson_data":{"__yson_type":"Int","__yson_data":${value}},"__yson_registers":"${registers}"}`;
+      }
+    );
     result = result.replace(
       /Counter\((Int|Long)\((-?\d+)\)\)/g,
       (_, type, value) => {
@@ -21986,6 +22665,20 @@
         value: value.__yson_data
       };
     }
+    if (value.__yson_type === "DedupCounter" && typeof value.__yson_data === "object" && typeof value.__yson_registers === "string") {
+      const counterValue = postprocessValue(value.__yson_data);
+      if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && counterValue.type === "Int") {
+        return {
+          type: "DedupCounter",
+          value: counterValue,
+          registers: value.__yson_registers
+        };
+      }
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "DedupCounter must contain Int"
+      );
+    }
     if (value.__yson_type === "Counter" && typeof value.__yson_data === "object") {
       const counterValue = postprocessValue(value.__yson_data);
       if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && (counterValue.type === "Int" || counterValue.type === "Long")) {
@@ -22074,6 +22767,7 @@
     isBinData,
     isCounter,
     isDate,
+    isDedupCounter,
     isInt,
     isLong,
     isObject,
@@ -22100,7 +22794,7 @@
     };
   }
   const name = "@yorkie-js/react";
-  const version = "0.7.5";
+  const version = "0.7.7";
   const pkg = {
     name,
     version