@yorkie-js/react 0.7.12 → 0.7.13

package/dist/yorkie-js-react.js

@@ -5792,7 +5792,7 @@
       }
     };
   }
-  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);
@@ -5837,13 +5837,20 @@
   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";
@@ -9688,10 +9695,20 @@
     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);
     }
@@ -9724,7 +9741,7 @@
       );
       addDataSizes(diff, diffTo, diffFrom);
       const nodesToDelete = this.findBetween(fromRight, toRight);
-      const [changes, removedNodes] = this.deleteNodes(
+      const [changes, removedNodes, alreadyRemovedIDs] = this.deleteNodes(
         nodesToDelete,
         editedAt,
         versionVector
@@ -9755,11 +9772,285 @@
       }
       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.
@@ -10029,11 +10320,28 @@
       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 = [];
@@ -10068,12 +10376,17 @@
       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`,
@@ -10545,7 +10858,7 @@
           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 ? {
@@ -10558,7 +10871,56 @@
         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.
@@ -10635,6 +10997,7 @@
           }
         }
       }
+      pairs.push(...this.rgaTreeSplit.drainPendingGCPairs());
       return [pairs, diff, changes, prevAttributes, attributesToRemove];
     }
     /**
@@ -10705,6 +11068,7 @@
           }
         }
       }
+      pairs.push(...this.rgaTreeSplit.drainPendingGCPairs());
       return [pairs, diff, changes, prevAttributes];
     }
     /**
@@ -10859,10 +11223,16 @@
       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;
@@ -10874,18 +11244,33 @@
     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,
@@ -10893,7 +11278,10 @@
         content,
         attributes,
         executedAt,
-        isUndoOp
+        isUndoOp,
+        restoreSpans,
+        restoreMode,
+        retombstoneSpans
       );
     }
     /**
@@ -10914,11 +11302,71 @@
         );
       }
       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(),
@@ -10927,7 +11375,8 @@
       );
       const reverseOp = this.toReverseOperation(
         removedValues,
-        text.normalizePos(this.fromPos)
+        text.normalizePos(this.fromPos),
+        removedSpans
       );
       root.acc(diff);
       for (const pair of pairs) {
@@ -10946,7 +11395,33 @@
         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) {
@@ -11084,6 +11559,26 @@
     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;
@@ -12384,6 +12879,10 @@
         }
         this.insNextID = split.id;
         tree.registerNode(split);
+        if (split.removedAt) {
+          tree.registerPendingGCPair(split, diff);
+          return [split, { data: 0, meta: 0 }];
+        }
       }
       return [split, diff];
     }
@@ -12481,7 +12980,11 @@
       }
       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;
@@ -12548,10 +13051,19 @@
   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);
       });
@@ -12653,6 +13165,25 @@
     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.
@@ -12839,6 +13370,7 @@
           }
         }
       );
+      pairs.push(...this.drainPendingGCPairs());
       return [pairs, changes, diff, prevAttributes, newAttrKeys];
     }
     /**
@@ -12942,6 +13474,7 @@
           }
         }
       );
+      pairs.push(...this.drainPendingGCPairs());
       return [pairs, changes, diff, prevAttributes];
     }
     /**
@@ -13105,6 +13638,9 @@
               parent = left.parent;
             }
           }
+          if (!parent.parent) {
+            break;
+          }
           parent.split(
             this,
             left !== parent ? parent.findOffset(left, true) + 1 : 0,
@@ -13164,6 +13700,7 @@
           }
         }
       }
+      pairs.push(...this.drainPendingGCPairs());
       return [
         changes,
         pairs,
@@ -13228,9 +13765,13 @@
      */
     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);
@@ -15679,6 +16220,25 @@
         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) {
@@ -16338,13 +16898,38 @@
       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;
@@ -18980,7 +19565,9 @@
         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.
@@ -18996,7 +19583,23 @@
         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) {
@@ -19239,6 +19842,10 @@
         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);
@@ -19246,6 +19853,28 @@
         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.
      */
@@ -19308,6 +19937,10 @@
       }
       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());
@@ -21531,7 +22164,7 @@
     };
   }
   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
@@ -23629,7 +24262,7 @@
     };
   }
   const name = "@yorkie-js/react";
-  const version = "0.7.12";
+  const version = "0.7.13";
   const pkg = {
     name,
     version