@yorkie-js/react 0.7.12 → 0.7.13

package/dist/yorkie-js-react.es.js

@@ -5790,7 +5790,7 @@ function createGrpcWebTransport(options) {
     }
   };
 }
-const file_yorkie_v1_resources = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
+const file_yorkie_v1_resources = /* @__PURE__ */ fileDesc("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", [file_google_protobuf_timestamp, file_google_protobuf_wrappers]);
 const SnapshotSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 0);
 const ChangePackSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 1);
 const ChangeSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 2);
@@ -5835,13 +5835,20 @@ var PresenceChange_ChangeType = /* @__PURE__ */ ((PresenceChange_ChangeType2) =>
 const PresenceSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 24);
 const CheckpointSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 26);
 const TextNodePosSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 27);
-const TimeTicketSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 28);
+const RestoreSpanSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 28);
+const TimeTicketSchema = /* @__PURE__ */ messageDesc(file_yorkie_v1_resources, 29);
 var ChannelEvent_Type = /* @__PURE__ */ ((ChannelEvent_Type2) => {
   ChannelEvent_Type2[ChannelEvent_Type2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
   ChannelEvent_Type2[ChannelEvent_Type2["PRESENCE"] = 1] = "PRESENCE";
   ChannelEvent_Type2[ChannelEvent_Type2["BROADCAST"] = 2] = "BROADCAST";
   return ChannelEvent_Type2;
 })(ChannelEvent_Type || {});
+var RestoreMode = /* @__PURE__ */ ((RestoreMode2) => {
+  RestoreMode2[RestoreMode2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  RestoreMode2[RestoreMode2["RESTORE"] = 1] = "RESTORE";
+  RestoreMode2[RestoreMode2["RETOMBSTONE"] = 2] = "RETOMBSTONE";
+  return RestoreMode2;
+})(RestoreMode || {});
 var ValueType = /* @__PURE__ */ ((ValueType2) => {
   ValueType2[ValueType2["NULL"] = 0] = "NULL";
   ValueType2[ValueType2["BOOLEAN"] = 1] = "BOOLEAN";
@@ -9686,10 +9693,20 @@ class RGATreeSplit {
   head;
   treeByIndex;
   treeByID;
+  /**
+   * `pendingGCPairs` buffers GC pairs for nodes that were created
+   * already-tombstoned by splitting a removed node. Such pieces inherit
+   * `removedAt` without ever passing through `remove()`, so they would
+   * otherwise never be registered for GC. Callers that split nodes
+   * (`edit`, `CRDTText.setStyle`, `CRDTText.removeStyle`) drain this
+   * buffer into their returned GC pairs.
+   */
+  pendingGCPairs;
   constructor() {
     this.head = RGATreeSplitNode.create(InitialRGATreeSplitNodeID);
     this.treeByIndex = new SplayTree();
     this.treeByID = new LLRBTree(RGATreeSplitNode.createComparator());
+    this.pendingGCPairs = [];
     this.treeByIndex.insert(this.head);
     this.treeByID.put(this.head.getID(), this.head);
   }
@@ -9722,7 +9739,7 @@ class RGATreeSplit {
     );
     addDataSizes(diff, diffTo, diffFrom);
     const nodesToDelete = this.findBetween(fromRight, toRight);
-    const [changes, removedNodes] = this.deleteNodes(
+    const [changes, removedNodes, alreadyRemovedIDs] = this.deleteNodes(
       nodesToDelete,
       editedAt,
       versionVector
@@ -9753,11 +9770,285 @@ class RGATreeSplit {
     }
     const pairs = [];
     const removedValues = [];
-    for (const [, removedNode] of removedNodes) {
-      pairs.push({ parent: this, child: removedNode });
+    const removedSpans = [];
+    for (const [id, removedNode] of removedNodes) {
+      if (!alreadyRemovedIDs.has(id)) {
+        pairs.push({ parent: this, child: removedNode });
+      }
       removedValues.push(removedNode.getValue());
+      removedSpans.push({
+        createdAt: removedNode.getCreatedAt(),
+        start: removedNode.getID().getOffset(),
+        end: removedNode.getID().getOffset() + removedNode.getContentLength(),
+        value: removedNode.getValue().substring(0)
+      });
+    }
+    pairs.push(...this.drainPendingGCPairs());
+    return [caretPos, pairs, diff, changes, removedValues, removedSpans];
+  }
+  /**
+   * `restore` re-establishes the characters described by `spans` under
+   * their ORIGINAL identities. For each span, per overlapping region:
+   *   - live piece exists       → skip (idempotent; another undo restored it)
+   *   - tombstoned piece exists → clear removedAt (un-tombstone)
+   *   - no piece exists (GC'd)  → recreate a node with the original ID
+   *
+   * Returns [untombstonedNodes, recreatedNodes, changes, liveDiff,
+   * pendingGCPairs]. `changes` describes the revived content as insertions
+   * (ascending index) so editor bindings and remote sync can be driven
+   * the same way as a normal edit.
+   *
+   * The caller must, in order: (1) register every pair in `pendingGCPairs`
+   * — these are fragments `splitNode` buffered while isolating a target
+   * range out of a larger tombstoned piece (see `drainPendingGCPairs`);
+   * (2) unregister GC pairs for `untombstonedNodes`. Registering first is
+   * required for `untombstonedNodes` entries whose node was itself one of
+   * those split-born fragments (a target isolated from the interior of a
+   * tombstone) — such a node was never registered under its own id, so
+   * step (1) creates the entry that step (2) then correctly walks from gc
+   * back to live; entries that remain tombstoned (siblings of the
+   * restored target) simply stay registered. Finally, `root.acc(liveDiff)`
+   * accounts the size of any nodes recreated from scratch (the GC'd-away
+   * case), which `splitNode`'s buffering does not cover.
+   */
+  restore(spans, executedAt, fallbackAnchor) {
+    const untombstoned = [];
+    const recreated = [];
+    const liveDiff = { data: 0, meta: 0 };
+    for (const span of spans) {
+      const pieces = this.findPiecesOverlapping(
+        span.createdAt,
+        span.start,
+        span.end
+      );
+      let cursor = span.start;
+      let pieceIdx = 0;
+      while (cursor < span.end) {
+        const piece = pieces[pieceIdx];
+        const pieceStart = piece ? piece.getID().getOffset() : Infinity;
+        const pieceEnd = piece ? pieceStart + piece.getContentLength() : Infinity;
+        if (piece && pieceStart <= cursor) {
+          const overlapEnd = Math.min(pieceEnd, span.end);
+          if (piece.isRemoved()) {
+            const [target] = this.isolateRange(piece, cursor, overlapEnd);
+            target.setRemovedAt(void 0);
+            this.treeByIndex.splayNode(target);
+            untombstoned.push(target);
+          }
+          cursor = overlapEnd;
+          if (overlapEnd >= pieceEnd) {
+            pieceIdx++;
+          }
+        } else {
+          const gapEnd = Math.min(pieceStart, span.end);
+          const value = span.value.substring(
+            cursor - span.start,
+            gapEnd - span.start
+          );
+          const newNode = RGATreeSplitNode.create(
+            RGATreeSplitNodeID.of(span.createdAt, cursor),
+            value
+          );
+          addDataSizes(liveDiff, newNode.getDataSize());
+          const prev = this.findRestoreAnchor(
+            span.createdAt,
+            cursor,
+            gapEnd,
+            executedAt,
+            fallbackAnchor
+          );
+          this.insertAfter(prev, newNode);
+          recreated.push(newNode);
+          cursor = gapEnd;
+        }
+      }
+    }
+    const pendingGCPairs = this.drainPendingGCPairs();
+    const changes = [];
+    for (const node of [...untombstoned, ...recreated]) {
+      const [from] = this.findIndexesFromRange(node.createPosRange());
+      changes.push({
+        actor: executedAt.getActorID(),
+        from,
+        to: from,
+        value: node.getValue()
+      });
+    }
+    changes.sort((a, b) => a.from - b.from);
+    return [untombstoned, recreated, changes, liveDiff, pendingGCPairs];
+  }
+  /**
+   * `retombstone` re-deletes the characters described by `spans` (redo of
+   * an identity-preserving undo). Only live pieces are affected; already
+   * removed or purged regions are skipped (idempotent).
+   *
+   * Returns [pairs, changes, diff]: GCPairs for the newly tombstoned
+   * nodes, the removed regions as deletions so editor bindings and remote
+   * sync can be driven the same way as a normal edit, and the
+   * metadata-size overhead from splitting the (live) pieces to isolate the
+   * target range. The caller must `root.acc(diff)` before registering
+   * `pairs`, mirroring how a normal edit's boundary splits are accounted
+   * before its resulting tombstones are registered. Indices are captured
+   * before each removal, so applying them in emission order stays
+   * consistent.
+   */
+  retombstone(spans, executedAt) {
+    const pairs = [];
+    const changes = [];
+    const diff = { data: 0, meta: 0 };
+    for (const span of spans) {
+      const pieces = this.findPiecesOverlapping(
+        span.createdAt,
+        span.start,
+        span.end
+      );
+      for (const piece of pieces) {
+        if (piece.isRemoved()) {
+          continue;
+        }
+        const pieceStart = piece.getID().getOffset();
+        const pieceEnd = pieceStart + piece.getContentLength();
+        const [target, splitDiff] = this.isolateRange(
+          piece,
+          Math.max(pieceStart, span.start),
+          Math.min(pieceEnd, span.end)
+        );
+        addDataSizes(diff, splitDiff);
+        const [from, to] = this.findIndexesFromRange(target.createPosRange());
+        target.remove(executedAt);
+        this.treeByIndex.splayNode(target);
+        pairs.push({ parent: this, child: target });
+        if (from < to) {
+          changes.push({ actor: executedAt.getActorID(), from, to });
+        }
+      }
     }
-    return [caretPos, pairs, diff, changes, removedValues];
+    pairs.push(...this.drainPendingGCPairs());
+    return [pairs, changes, diff];
+  }
+  /**
+   * `findPiecesOverlapping` collects existing nodes (live or tombstoned)
+   * belonging to the insertion `createdAt` that overlap the absolute-offset
+   * interval [start, end), in ascending offset order. Works by descending
+   * floorEntry probes over treeByID.
+   */
+  findPiecesOverlapping(createdAt, start, end) {
+    const pieces = [];
+    let probe = end - 1;
+    while (probe >= 0) {
+      const key = RGATreeSplitNodeID.of(createdAt, probe);
+      const entry = this.treeByID.floorEntry(key);
+      if (!entry || !entry.key.hasSameCreatedAt(key)) {
+        break;
+      }
+      const node = entry.value;
+      const nodeStart = node.getID().getOffset();
+      const nodeEnd = nodeStart + node.getContentLength();
+      if (nodeEnd <= start) {
+        break;
+      }
+      if (nodeStart < end && nodeEnd > start) {
+        pieces.push(node);
+      }
+      if (nodeStart <= start) {
+        break;
+      }
+      probe = nodeStart - 1;
+    }
+    return pieces.reverse();
+  }
+  /**
+   * `findPieceCovering` returns the node of insertion `createdAt` whose
+   * absolute-offset range covers `offset`, if present.
+   */
+  findPieceCovering(createdAt, offset) {
+    const key = RGATreeSplitNodeID.of(createdAt, offset);
+    const entry = this.treeByID.floorEntry(key);
+    if (!entry || !entry.key.hasSameCreatedAt(key)) {
+      return;
+    }
+    const node = entry.value;
+    const nodeStart = node.getID().getOffset();
+    const nodeEnd = nodeStart + node.getContentLength();
+    if (nodeStart <= offset && offset < nodeEnd) {
+      return node;
+    }
+    return;
+  }
+  /**
+   * `findRestoreAnchor` returns the physical node to insert a recreated
+   * fragment [gapStart, gapEnd) of insertion `createdAt` AFTER.
+   *
+   * Resolution ladder (all rules key on op-carried data + ID lookups only):
+   *  (a) a piece covering gapEnd exists → directly before it
+   *      (originally-adjacent successor; exact original slot)
+   *  (b) nearest surviving piece of the same insertion left of gapStart
+   *      → directly after it
+   *  (c) rightmost surviving piece of the same insertion (must be right
+   *      of the gap) → directly before it
+   *  (d) the operation's fallback anchor (refined) — same exposure as the
+   *      current implementation's fromPos; see design-doc caveat
+   *  (e) head (deterministic last resort)
+   */
+  findRestoreAnchor(createdAt, gapStart, gapEnd, executedAt, fallbackAnchor) {
+    const succ = this.findPieceCovering(createdAt, gapEnd);
+    if (succ) {
+      return succ.getPrev();
+    }
+    if (gapStart > 0) {
+      const key = RGATreeSplitNodeID.of(createdAt, gapStart - 1);
+      const entry = this.treeByID.floorEntry(key);
+      if (entry && entry.key.hasSameCreatedAt(key)) {
+        return entry.value;
+      }
+    }
+    const rightmostKey = RGATreeSplitNodeID.of(
+      createdAt,
+      Number.MAX_SAFE_INTEGER
+    );
+    const rightmost = this.treeByID.floorEntry(rightmostKey);
+    if (rightmost && rightmost.key.hasSameCreatedAt(rightmostKey) && rightmost.value.getID().getOffset() >= gapEnd) {
+      return rightmost.value.getPrev();
+    }
+    if (fallbackAnchor) {
+      try {
+        const refined = this.refinePos(fallbackAnchor);
+        const [left] = this.findNodeWithSplit(refined, executedAt);
+        return left;
+      } catch {
+      }
+    }
+    return this.head;
+  }
+  /**
+   * `isolateRange` splits `piece` so that a node exactly covering the
+   * absolute-offset interval [from, to) exists, and returns it along with
+   * the net metadata-size overhead the split(s) introduced.
+   *
+   * When `piece` is live, this overhead is a normal live-bucket cost (same
+   * as any other boundary split) and the caller should `root.acc` it.
+   * When `piece` is tombstoned, `splitNode` itself buffers the overhead of
+   * any born-removed fragment via `pendingGCPairs` (see `drainPendingGCPairs`),
+   * so the returned diff is zero in that case — the caller must still
+   * drain and register those pairs.
+   *
+   * Requires: pieceStart <= from < to <= pieceEnd.
+   */
+  isolateRange(piece, from, to) {
+    const diff = { data: 0, meta: 0 };
+    let node = piece;
+    const nodeStart = node.getID().getOffset();
+    if (from > nodeStart) {
+      const [right, splitDiff] = this.splitNode(node, from - nodeStart);
+      addDataSizes(diff, splitDiff);
+      node = right;
+    }
+    const newStart = node.getID().getOffset();
+    if (to < newStart + node.getContentLength()) {
+      const [, splitDiff] = this.splitNode(node, to - newStart);
+      addDataSizes(diff, splitDiff);
+    }
+    return [node, diff];
   }
   /**
    * `indexToPos` finds RGATreeSplitPos of given offset.
@@ -10027,11 +10318,28 @@ class RGATreeSplit {
     splitNode.setInsPrev(node);
     addDataSizes(diff, node.getDataSize(), splitNode.getDataSize());
     subDataSize(diff, prvSize);
+    if (splitNode.isRemoved()) {
+      this.pendingGCPairs.push({
+        parent: this,
+        child: splitNode,
+        gcOnlySize: diff
+      });
+      return [splitNode, { data: 0, meta: 0 }];
+    }
     return [splitNode, diff];
   }
+  /**
+   * `drainPendingGCPairs` returns the GC pairs buffered for born-tombstoned
+   * split pieces and clears the buffer.
+   */
+  drainPendingGCPairs() {
+    const pairs = this.pendingGCPairs;
+    this.pendingGCPairs = [];
+    return pairs;
+  }
   deleteNodes(candidates, editedAt, vector) {
     if (!candidates.length) {
-      return [[], /* @__PURE__ */ new Map()];
+      return [[], /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()];
     }
     const isLocal = vector === void 0 || vector.size() === 0;
     const nodesToRemove = [];
@@ -10066,12 +10374,17 @@ class RGATreeSplit {
     nodesToKeep.push(rightEdge);
     const changes = this.makeChanges(nodesToKeep, editedAt);
     const removedNodes = /* @__PURE__ */ new Map();
+    const alreadyRemovedIDs = /* @__PURE__ */ new Set();
     for (const node of nodesToRemove) {
-      removedNodes.set(node.getID().toIDString(), node);
+      const id = node.getID().toIDString();
+      if (node.isRemoved()) {
+        alreadyRemovedIDs.add(id);
+      }
+      removedNodes.set(id, node);
       node.remove(editedAt);
     }
     this.deleteIndexNodes(nodesToKeep);
-    return [changes, removedNodes];
+    return [changes, removedNodes, alreadyRemovedIDs];
   }
   /**
    * `findEdgesOfCandidates` finds the edges outside `candidates`,
@@ -10543,7 +10856,7 @@ class CRDTText extends CRDTElement {
         crdtTextValue.setAttr(k, v, editedAt);
       }
     }
-    const [caretPos, pairs, diff, valueChanges, removedValues] = this.rgaTreeSplit.edit(range, editedAt, crdtTextValue, versionVector);
+    const [caretPos, pairs, diff, valueChanges, removedValues, removedSpans] = this.rgaTreeSplit.edit(range, editedAt, crdtTextValue, versionVector);
     const changes = valueChanges.map((change) => ({
       ...change,
       value: change.value ? {
@@ -10556,7 +10869,56 @@ class CRDTText extends CRDTElement {
       type: "content"
       /* Content */
     }));
-    return [changes, pairs, diff, [caretPos, caretPos], removedValues];
+    return [
+      changes,
+      pairs,
+      diff,
+      [caretPos, caretPos],
+      removedValues,
+      removedSpans
+    ];
+  }
+  /**
+   * `restore` re-establishes removed characters under their original
+   * identities (identity-preserving undo of a deletion).
+   */
+  restore(spans, executedAt, fallbackAnchor) {
+    const [untombstoned, recreated, valueChanges, liveDiff, pendingGCPairs] = this.rgaTreeSplit.restore(spans, executedAt, fallbackAnchor);
+    return [
+      untombstoned,
+      recreated,
+      this.toTextChanges(valueChanges),
+      liveDiff,
+      pendingGCPairs
+    ];
+  }
+  /**
+   * `retombstone` re-deletes previously restored characters (redo).
+   */
+  retombstone(spans, executedAt) {
+    const [pairs, valueChanges, diff] = this.rgaTreeSplit.retombstone(
+      spans,
+      executedAt
+    );
+    return [pairs, this.toTextChanges(valueChanges), diff];
+  }
+  /**
+   * `toTextChanges` wraps raw RGATreeSplit value changes into `TextChange`s,
+   * mirroring the mapping used by `edit`.
+   */
+  toTextChanges(valueChanges) {
+    return valueChanges.map((change) => ({
+      ...change,
+      value: change.value ? {
+        attributes: parseObjectValues(change.value.getAttributes()),
+        content: change.value.getContent()
+      } : {
+        attributes: void 0,
+        content: ""
+      },
+      type: "content"
+      /* Content */
+    }));
   }
   /**
    * `setStyle` applies the style of the given range.
@@ -10633,6 +10995,7 @@ class CRDTText extends CRDTElement {
         }
       }
     }
+    pairs.push(...this.rgaTreeSplit.drainPendingGCPairs());
     return [pairs, diff, changes, prevAttributes, attributesToRemove];
   }
   /**
@@ -10703,6 +11066,7 @@ class CRDTText extends CRDTElement {
         }
       }
     }
+    pairs.push(...this.rgaTreeSplit.drainPendingGCPairs());
     return [pairs, diff, changes, prevAttributes];
   }
   /**
@@ -10857,10 +11221,16 @@ class CRDTText extends CRDTElement {
     const pairs = [];
     for (const node of this.rgaTreeSplit) {
       if (node.getRemovedAt()) {
-        pairs.push({ parent: this.rgaTreeSplit, child: node });
+        pairs.push({
+          parent: this.rgaTreeSplit,
+          child: node,
+          gcOnlySize: node.getDataSize()
+        });
       }
       for (const p of node.getValue().getGCPairs()) {
-        pairs.push(p);
+        pairs.push(
+          node.getRemovedAt() ? { ...p, gcOnlySize: p.child.getDataSize() } : p
+        );
       }
     }
     return pairs;
@@ -10872,18 +11242,33 @@ class EditOperation extends Operation {
   content;
   attributes;
   isUndoOp;
-  constructor(parentCreatedAt, fromPos, toPos, content, attributes, executedAt, isUndoOp) {
+  restoreSpans;
+  restoreMode;
+  // `retombstoneSpans` is the companion span set for an identity-preserving
+  // reverse op. `restoreSpans` describes content the reversed edit removed;
+  // `retombstoneSpans` describes content the reversed edit inserted (non-empty
+  // only for the reverse of a replace). `restoreMode` picks the direction:
+  // 'restore' revives restoreSpans and re-removes retombstoneSpans; a
+  // 'retombstone' op (the redo) does the opposite. Reversing an edit that both
+  // inserts and deletes as two identity operations — rather than
+  // copy-reinserting the deleted text as a fresh node — keeps a later revived
+  // neighbour in its original relative order.
+  retombstoneSpans;
+  constructor(parentCreatedAt, fromPos, toPos, content, attributes, executedAt, isUndoOp, restoreSpans, restoreMode, retombstoneSpans) {
     super(parentCreatedAt, executedAt);
     this.fromPos = fromPos;
     this.toPos = toPos;
     this.content = content;
     this.attributes = attributes;
     this.isUndoOp = isUndoOp;
+    this.restoreSpans = restoreSpans;
+    this.restoreMode = restoreMode;
+    this.retombstoneSpans = retombstoneSpans;
   }
   /**
    * `create` creates a new instance of EditOperation.
    */
-  static create(parentCreatedAt, fromPos, toPos, content, attributes, executedAt, isUndoOp) {
+  static create(parentCreatedAt, fromPos, toPos, content, attributes, executedAt, isUndoOp, restoreSpans, restoreMode, retombstoneSpans) {
     return new EditOperation(
       parentCreatedAt,
       fromPos,
@@ -10891,7 +11276,10 @@ class EditOperation extends Operation {
       content,
       attributes,
       executedAt,
-      isUndoOp
+      isUndoOp,
+      restoreSpans,
+      restoreMode,
+      retombstoneSpans
     );
   }
   /**
@@ -10912,11 +11300,71 @@ class EditOperation extends Operation {
       );
     }
     const text = parentObject;
+    if (this.restoreSpans || this.retombstoneSpans) {
+      const isRetombstone = this.restoreMode === "retombstone";
+      const toRestore = (isRetombstone ? this.retombstoneSpans : this.restoreSpans) ?? [];
+      const toRetombstone = (isRetombstone ? this.restoreSpans : this.retombstoneSpans) ?? [];
+      const opInfos = [];
+      const totalDiff = { data: 0, meta: 0 };
+      const toOpInfo = (c) => ({
+        type: "edit",
+        from: c.from,
+        to: c.to,
+        value: c.value,
+        path: root.createPath(this.getParentCreatedAt())
+      });
+      if (toRetombstone.length) {
+        const [pairs2, changes2, diff2] = text.retombstone(
+          toRetombstone,
+          this.getExecutedAt()
+        );
+        addDataSizes(totalDiff, diff2);
+        for (const pair of pairs2) {
+          root.registerGCPair(pair);
+        }
+        for (const c of changes2) {
+          opInfos.push(toOpInfo(c));
+        }
+      }
+      if (toRestore.length) {
+        const [untombstoned, , changes2, liveDiff, pendingGCPairs] = text.restore(toRestore, this.getExecutedAt(), this.fromPos);
+        for (const pair of pendingGCPairs) {
+          root.registerGCPair(pair);
+        }
+        for (const node of untombstoned) {
+          root.unregisterGCPair({
+            parent: text.getRGATreeSplit(),
+            child: node
+          });
+        }
+        addDataSizes(totalDiff, liveDiff);
+        for (const c of changes2) {
+          opInfos.push(toOpInfo(c));
+        }
+      }
+      root.acc(totalDiff);
+      return {
+        opInfos,
+        // Reverse keeps the same span sets and flips the direction.
+        reverseOp: EditOperation.create(
+          this.getParentCreatedAt(),
+          this.fromPos,
+          this.toPos,
+          "",
+          /* @__PURE__ */ new Map(),
+          void 0,
+          true,
+          this.restoreSpans,
+          isRetombstone ? "restore" : "retombstone",
+          this.retombstoneSpans
+        )
+      };
+    }
     if (this.isUndoOp) {
       this.fromPos = text.refinePos(this.fromPos);
       this.toPos = text.refinePos(this.toPos);
     }
-    const [changes, pairs, diff, , removedValues] = text.edit(
+    const [changes, pairs, diff, , removedValues, removedSpans] = text.edit(
       [this.fromPos, this.toPos],
       this.content,
       this.getExecutedAt(),
@@ -10925,7 +11373,8 @@ class EditOperation extends Operation {
     );
     const reverseOp = this.toReverseOperation(
       removedValues,
-      text.normalizePos(this.fromPos)
+      text.normalizePos(this.fromPos),
+      removedSpans
     );
     root.acc(diff);
     for (const pair of pairs) {
@@ -10944,7 +11393,33 @@ class EditOperation extends Operation {
       reverseOp
     };
   }
-  toReverseOperation(removedValues, fromPos) {
+  toReverseOperation(removedValues, fromPos, removedSpans) {
+    if (removedSpans.length || this.content?.length) {
+      let insertedSpans;
+      if (this.content?.length) {
+        const value = CRDTTextValue.create(this.content);
+        insertedSpans = [
+          {
+            createdAt: this.getExecutedAt(),
+            start: 0,
+            end: value.length,
+            value
+          }
+        ];
+      }
+      return EditOperation.create(
+        this.getParentCreatedAt(),
+        fromPos,
+        fromPos,
+        "",
+        /* @__PURE__ */ new Map(),
+        void 0,
+        true,
+        removedSpans.length ? removedSpans : void 0,
+        "restore",
+        insertedSpans
+      );
+    }
     const content = removedValues?.length ? removedValues.map((v) => v.getContent()).join("") : "";
     let attrs;
     if (removedValues.length === 1) {
@@ -11082,6 +11557,26 @@ class EditOperation extends Operation {
   getAttributes() {
     return this.attributes || /* @__PURE__ */ new Map();
   }
+  /**
+   * `getRestoreSpans` returns the identity-preserving restore payload, if
+   * this is a restore/retombstone operation.
+   */
+  getRestoreSpans() {
+    return this.restoreSpans;
+  }
+  /**
+   * `getRestoreMode` returns the identity-preserving mode of this Edit.
+   */
+  getRestoreMode() {
+    return this.restoreMode;
+  }
+  /**
+   * `getRetombstoneSpans` returns the companion span set (content the reversed
+   * edit inserted) for an identity-preserving reverse op, if any.
+   */
+  getRetombstoneSpans() {
+    return this.retombstoneSpans;
+  }
 }
 class StyleOperation extends Operation {
   fromPos;
@@ -12382,6 +12877,10 @@ class CRDTTreeNode extends IndexTreeNode {
       }
       this.insNextID = split.id;
       tree.registerNode(split);
+      if (split.removedAt) {
+        tree.registerPendingGCPair(split, diff);
+        return [split, { data: 0, meta: 0 }];
+      }
     }
     return [split, diff];
   }
@@ -12479,7 +12978,11 @@ class CRDTTreeNode extends IndexTreeNode {
     }
     for (const node of this.attrs) {
       if (node.getRemovedAt()) {
-        pairs.push({ parent: this, child: node });
+        pairs.push({
+          parent: this,
+          child: node,
+          gcOnlySize: node.getDataSize()
+        });
       }
     }
     return pairs;
@@ -12546,10 +13049,19 @@ function toTestTreeNode(node) {
 class CRDTTree extends CRDTElement {
   indexTree;
   nodeMapByID;
+  /**
+   * `pendingGCPairs` buffers GC pairs for nodes that were created
+   * already-tombstoned by splitting a removed node. Such pieces inherit
+   * `removedAt` without ever passing through `remove()`, so they would
+   * otherwise never be registered for GC. `edit` and `style` drain this
+   * buffer into their returned GC pairs.
+   */
+  pendingGCPairs;
   constructor(root, createdAt) {
     super(createdAt);
     this.indexTree = new IndexTree(root);
     this.nodeMapByID = new LLRBTree(CRDTTreeNodeID.createComparator());
+    this.pendingGCPairs = [];
     this.indexTree.traverseAll((node) => {
       this.nodeMapByID.put(node.id, node);
     });
@@ -12651,6 +13163,25 @@ class CRDTTree extends CRDTElement {
   registerNode(node) {
     this.nodeMapByID.put(node.id, node);
   }
+  /**
+   * `registerPendingGCPair` buffers a GC pair for a node that was born
+   * tombstoned (split off an already-removed node). The pair is picked up
+   * by the next `edit` or `style` call via `drainPendingGCPairs`. `size`
+   * is the net-new size created by the split; it is accounted to
+   * docSize.gc at registration since the node was never live.
+   */
+  registerPendingGCPair(node, size) {
+    this.pendingGCPairs.push({ parent: this, child: node, gcOnlySize: size });
+  }
+  /**
+   * `drainPendingGCPairs` returns the buffered GC pairs and clears the
+   * buffer.
+   */
+  drainPendingGCPairs() {
+    const pairs = this.pendingGCPairs;
+    this.pendingGCPairs = [];
+    return pairs;
+  }
   /**
    * `findNodesAndSplitText` finds `TreePos` of the given `CRDTTreeNodeID` and
    * splits nodes if the position is in the middle of a text node.
@@ -12837,6 +13368,7 @@ class CRDTTree extends CRDTElement {
         }
       }
     );
+    pairs.push(...this.drainPendingGCPairs());
     return [pairs, changes, diff, prevAttributes, newAttrKeys];
   }
   /**
@@ -12940,6 +13472,7 @@ class CRDTTree extends CRDTElement {
         }
       }
     );
+    pairs.push(...this.drainPendingGCPairs());
     return [pairs, changes, diff, prevAttributes];
   }
   /**
@@ -13103,6 +13636,9 @@ class CRDTTree extends CRDTElement {
             parent = left.parent;
           }
         }
+        if (!parent.parent) {
+          break;
+        }
         parent.split(
           this,
           left !== parent ? parent.findOffset(left, true) + 1 : 0,
@@ -13162,6 +13698,7 @@ class CRDTTree extends CRDTElement {
         }
       }
     }
+    pairs.push(...this.drainPendingGCPairs());
     return [
       changes,
       pairs,
@@ -13226,9 +13763,13 @@ class CRDTTree extends CRDTElement {
    */
   getGCPairs() {
     const pairs = [];
-    this.indexTree.traverse((node) => {
+    this.indexTree.traverseAll((node) => {
       if (node.getRemovedAt()) {
-        pairs.push({ parent: this, child: node });
+        pairs.push({
+          parent: this,
+          child: node,
+          gcOnlySize: node.getDataSize()
+        });
       }
       for (const p of node.getGCPairs()) {
         pairs.push(p);
@@ -15677,6 +16218,25 @@ function toOperation(operation) {
       pbAttributes[key] = value;
     }
     pbEditOperation.executedAt = toTimeTicket(editOperation.getExecutedAt());
+    const toPbSpan = (span) => {
+      const pbSpan = create(RestoreSpanSchema);
+      pbSpan.createdAt = toTimeTicket(span.createdAt);
+      pbSpan.start = span.start;
+      pbSpan.end = span.end;
+      pbSpan.content = span.value.getContent();
+      const pbSpanAttrs = pbSpan.attributes;
+      for (const [key, value] of Object.entries(span.value.getAttributes())) {
+        pbSpanAttrs[key] = value;
+      }
+      return pbSpan;
+    };
+    const restoreSpans = editOperation.getRestoreSpans();
+    const retombstoneSpans = editOperation.getRetombstoneSpans();
+    if (restoreSpans && restoreSpans.length || retombstoneSpans && retombstoneSpans.length) {
+      pbEditOperation.restoreSpans = (restoreSpans ?? []).map(toPbSpan);
+      pbEditOperation.retombstoneSpans = (retombstoneSpans ?? []).map(toPbSpan);
+      pbEditOperation.restoreMode = editOperation.getRestoreMode() === "retombstone" ? RestoreMode.RETOMBSTONE : RestoreMode.RESTORE;
+    }
     pbOperation.body.case = "edit";
     pbOperation.body.value = pbEditOperation;
   } else if (operation instanceof StyleOperation) {
@@ -16336,13 +16896,38 @@ function fromOperation(pbOperation) {
     Object.entries(pbEditOperation.attributes).forEach(([key, value]) => {
       attributes.set(key, value);
     });
+    const executedAt = fromTimeTicket(pbEditOperation.executedAt);
+    const fromPbSpan = (pbSpan) => {
+      const value = CRDTTextValue.create(pbSpan.content);
+      for (const [key, attr] of Object.entries(pbSpan.attributes)) {
+        value.setAttr(key, attr, executedAt);
+      }
+      return {
+        createdAt: fromTimeTicket(pbSpan.createdAt),
+        start: pbSpan.start,
+        end: pbSpan.end,
+        value
+      };
+    };
+    let restoreSpans;
+    let retombstoneSpans;
+    let restoreMode;
+    if (pbEditOperation.restoreSpans.length || pbEditOperation.retombstoneSpans.length) {
+      restoreSpans = pbEditOperation.restoreSpans.map(fromPbSpan);
+      retombstoneSpans = pbEditOperation.retombstoneSpans.map(fromPbSpan);
+      restoreMode = pbEditOperation.restoreMode === RestoreMode.RETOMBSTONE ? "retombstone" : "restore";
+    }
     return EditOperation.create(
       fromTimeTicket(pbEditOperation.parentCreatedAt),
       fromTextNodePos(pbEditOperation.from),
       fromTextNodePos(pbEditOperation.to),
       pbEditOperation.content,
       attributes,
-      fromTimeTicket(pbEditOperation.executedAt)
+      executedAt,
+      restoreMode ? true : void 0,
+      restoreSpans,
+      restoreMode,
+      retombstoneSpans
     );
   } else if (pbOperation.body.case === "style") {
     const pbStyleOperation = pbOperation.body.value;
@@ -18978,7 +19563,9 @@ class Tree {
       CRDTTreePos.fromStruct(range[0]),
       CRDTTreePos.fromStruct(range[1])
     ];
-    return this.tree.posRangeToIndexRange(posRange);
+    const indexRange = this.tree.posRangeToIndexRange(posRange);
+    this.registerPendingGCPairs();
+    return indexRange;
   }
   /**
    * `posRangeToPathRange` converts the position range into the path range.
@@ -18994,7 +19581,23 @@ class Tree {
       CRDTTreePos.fromStruct(range[0]),
       CRDTTreePos.fromStruct(range[1])
     ];
-    return this.tree.posRangeToPathRange(posRange);
+    const pathRange = this.tree.posRangeToPathRange(posRange);
+    this.registerPendingGCPairs();
+    return pathRange;
+  }
+  /**
+   * `registerPendingGCPairs` registers with the root any GC pairs the tree
+   * buffered while resolving a position. `posRangeToIndexRange` and
+   * `posRangeToPathRange` split text nodes to locate a position; when the
+   * position lands inside a tombstoned node the split produces a
+   * born-removed piece. Unlike edit/style/removeStyle, these read-path
+   * conversions emit no operation, so the buffered pairs would otherwise
+   * never reach the root and the piece would leak (invisible to GC).
+   */
+  registerPendingGCPairs() {
+    for (const pair of this.tree.drainPendingGCPairs()) {
+      this.context.registerGCPair(pair);
+    }
   }
 }
 function createJSON(context, target) {
@@ -19237,6 +19840,10 @@ class CRDTRoot {
       return;
     }
     this.gcPairMap.set(pair.child.toIDString(), pair);
+    if (pair.gcOnlySize) {
+      addDataSizes(this.docSize.gc, pair.gcOnlySize);
+      return;
+    }
     const size = this.gcPairMap.get(pair.child.toIDString()).child.getDataSize();
     addDataSizes(this.docSize.gc, size);
     subDataSize(this.docSize.live, size);
@@ -19244,6 +19851,28 @@ class CRDTRoot {
       this.docSize.live.meta += TimeTicketSize;
     }
   }
+  /**
+   * `unregisterGCPair` removes the given pair from the hash table. Called
+   * when a tombstoned node is revived (un-tombstoned) by an
+   * identity-preserving undo, so that a later re-registration (redo) is
+   * not swallowed by the toggle in `registerGCPair`.
+   *
+   * NOTE: must be called AFTER the node's removedAt has been cleared, so
+   * `getDataSize()` no longer includes the tombstone ticket.
+   */
+  unregisterGCPair(pair) {
+    const registered = this.gcPairMap.get(pair.child.toIDString());
+    if (!registered) {
+      return;
+    }
+    this.gcPairMap.delete(pair.child.toIDString());
+    const size = pair.child.getDataSize();
+    subDataSize(this.docSize.gc, size);
+    addDataSizes(this.docSize.live, size);
+    if (!(pair.child instanceof RHTNode)) {
+      this.docSize.gc.meta -= TimeTicketSize;
+    }
+  }
   /**
    * `getElementMapSize` returns the size of element map.
    */
@@ -19306,6 +19935,10 @@ class CRDTRoot {
     }
     for (const [, pair] of this.gcPairMap) {
       const removedAt = pair.child.getRemovedAt();
+      if (!removedAt) {
+        this.unregisterGCPair(pair);
+        continue;
+      }
       if (removedAt && minSyncedVersionVector?.afterOrEqual(removedAt)) {
         pair.parent.purge(pair.child);
         subDataSize(this.docSize.gc, pair.child.getDataSize());
@@ -21529,7 +22162,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name$1 = "@yorkie-js/sdk";
-const version$1 = "0.7.12";
+const version$1 = "0.7.13";
 const pkg$1 = {
   name: name$1,
   version: version$1
@@ -23627,7 +24260,7 @@ if (typeof globalThis !== "undefined") {
   };
 }
 const name = "@yorkie-js/react";
-const version = "0.7.12";
+const version = "0.7.13";
 const pkg = {
   name,
   version