@yorkie-js/sdk 0.7.6 → 0.7.8

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

@@ -358,7 +358,7 @@ function isScalarZeroValue(type, value) {
   }
 }
 const IMPLICIT$3 = 2;
-const unsafeLocal = Symbol.for("reflect unsafe local");
+const unsafeLocal = /* @__PURE__ */ Symbol.for("reflect unsafe local");
 function unsafeOneofCase(target, oneof) {
   const c = target[oneof.localName].case;
   if (c === void 0) {
@@ -584,7 +584,7 @@ function convertObjectValues(obj, fn) {
   }
   return ret;
 }
-const tokenZeroMessageField = Symbol();
+const tokenZeroMessageField = /* @__PURE__ */ Symbol();
 const messagePrototypes = /* @__PURE__ */ new WeakMap();
 function createZeroMessage(desc) {
   let msg;
@@ -686,7 +686,7 @@ class FieldError extends Error {
 function isFieldError(arg) {
   return arg instanceof Error && errorNames.includes(arg.name) && "field" in arg && typeof arg.field == "function";
 }
-const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+const symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
 function getTextEncoding() {
   if (globalThis[symbol] == void 0) {
     const te = new globalThis.TextEncoder();
@@ -4054,7 +4054,7 @@ function readScalarField(msg, field, json) {
     msg.set(field, scalarValue);
   }
 }
-const tokenIgnoredUnknownEnum = Symbol();
+const tokenIgnoredUnknownEnum = /* @__PURE__ */ Symbol();
 function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
   if (json === null) {
     if (desc.typeName == "google.protobuf.NullValue") {
@@ -4080,7 +4080,7 @@ function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
   }
   throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
 }
-const tokenNull = Symbol();
+const tokenNull = /* @__PURE__ */ Symbol();
 function scalarFromJson(field, json, nullAsZeroValue) {
   if (json === null) {
     if (nullAsZeroValue) {
@@ -5901,6 +5901,8 @@ class YorkieError extends Error {
     this.message = message;
     this.toString = () => `[code=${this.code}]: ${this.message}`;
   }
+  code;
+  message;
   name = "YorkieError";
   stack;
 }
@@ -11130,6 +11132,32 @@ class IndexTreeNode {
       }
       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(
@@ -11906,8 +11934,14 @@ class CRDTTreeNode extends IndexTreeNode {
       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);
@@ -12131,7 +12165,7 @@ class CRDTTree extends CRDTElement {
    * 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;
     }
@@ -12141,10 +12175,13 @@ class CRDTTree extends CRDTElement {
       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;
@@ -12485,6 +12522,25 @@ class CRDTTree extends CRDTElement {
     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) {
+          if (toLeft !== toParent) {
+            collectFromLeft = next;
+            collectFromParent = toParent;
+          }
+          break;
+        }
+        current = next;
+      }
+    }
     const fromIdx = this.toIndex(fromParent, fromLeft);
     const fromPath = this.toPath(fromParent, fromLeft);
     const nodesToBeRemoved = [];
@@ -12493,8 +12549,8 @@ class CRDTTree extends CRDTElement {
     const toBeMergedNodes = [];
     const preTombstoned = /* @__PURE__ */ new Set();
     this.traverseInPosRange(
-      fromParent,
-      fromLeft,
+      collectFromParent,
+      collectFromLeft,
       toParent,
       toLeft,
       ([node, tokenType], ended) => {
@@ -12542,6 +12598,7 @@ class CRDTTree extends CRDTElement {
       tokensToBeRemoved,
       editedAt
     );
+    const mergeLevel = toBeMergedNodes.length;
     const pairs = [];
     for (const node of nodesToBeRemoved) {
       if (node.remove(editedAt)) {
@@ -12598,9 +12655,20 @@ class CRDTTree extends CRDTElement {
       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
         );
@@ -12657,7 +12725,15 @@ class CRDTTree extends CRDTElement {
         }
       }
     }
-    return [changes, pairs, diff, nodesToBeRemoved, fromIdx];
+    return [
+      changes,
+      pairs,
+      diff,
+      nodesToBeRemoved,
+      fromIdx,
+      mergeLevel,
+      preTombstoned
+    ];
   }
   /**
    * `editT` edits the given range with the given value.
@@ -13098,11 +13174,35 @@ class CRDTTree extends CRDTElement {
     return [prev, prev.isText ? TokenType.Text : TokenType.End];
   }
 }
-function clearRemovedAt(node) {
-  traverseAll(node, (n) => {
+function cloneAndDropPreTombstoned(node, preTombstoned) {
+  const clone = node.deepcopy();
+  filterChildren(clone, preTombstoned);
+  traverseAll(clone, (n) => {
     n.removedAt = void 0;
-    n.visibleSize = n.totalSize;
+    if (n.isText) {
+      n.visibleSize = n.value.length;
+      n.totalSize = n.value.length;
+      return;
+    }
+    let size = 0;
+    for (const child of n._children) size += child.paddedSize();
+    n.visibleSize = size;
+    n.totalSize = size;
   });
+  return clone;
+}
+function filterChildren(node, preTombstoned) {
+  const all = node._children;
+  if (!all) return;
+  const kept = [];
+  for (const child of all) {
+    if (preTombstoned.has(child.id.toIDString())) {
+      continue;
+    }
+    filterChildren(child, preTombstoned);
+    kept.push(child);
+  }
+  node._children = kept;
 }
 class TreeEditOperation extends Operation {
   fromPos;
@@ -13174,7 +13274,15 @@ class TreeEditOperation extends Operation {
         this.toPos = tree.findPos(this.toIdx);
       }
     }
-    const [changes, pairs, diff, removedNodes, preEditFromIdx] = tree.edit(
+    const [
+      changes,
+      pairs,
+      diff,
+      removedNodes,
+      preEditFromIdx,
+      mergeLevel,
+      preTombstoned
+    ] = tree.edit(
       [this.fromPos, this.toPos],
       this.contents?.map((content) => content.deepcopy()),
       this.splitLevel,
@@ -13207,10 +13315,16 @@ class TreeEditOperation extends Operation {
     );
     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) {
+      reverseOp = this.toReverseOperation(
+        tree,
+        removedNodes,
+        preEditFromIdx,
+        preTombstoned,
+        mergeLevel
+      );
+    } else if (isPureSplit) {
       reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
     }
     root.acc(diff);
@@ -13247,7 +13361,7 @@ class TreeEditOperation extends Operation {
    * @param removedNodes - Nodes that were removed by this edit
    * @param preEditFromIdx - The from index captured BEFORE the edit
    */
-  toReverseOperation(tree, removedNodes, preEditFromIdx) {
+  toReverseOperation(tree, removedNodes, preEditFromIdx, preTombstoned, mergeLevel) {
     if (this.redoSplitLevel !== void 0 && this.redoSplitLevel > 0) {
       const splitRedoFromPos = tree.findPos(preEditFromIdx);
       const splitRedoOp = TreeEditOperation.create(
@@ -13266,19 +13380,36 @@ class TreeEditOperation extends Operation {
       );
       return splitRedoOp;
     }
+    if (mergeLevel && mergeLevel > 0) {
+      const splitFromPos = tree.findPos(preEditFromIdx);
+      const splitUndoOp = TreeEditOperation.create(
+        this.getParentCreatedAt(),
+        splitFromPos,
+        splitFromPos,
+        void 0,
+        // no inserted content — split creates boundaries
+        mergeLevel,
+        // splitLevel = number of merged boundaries
+        void 0,
+        // executedAt assigned at undo time
+        true,
+        // isUndoOp
+        preEditFromIdx,
+        preEditFromIdx
+      );
+      return splitUndoOp;
+    }
     const insertedContentSize = this.contents ? this.contents.reduce((sum, node) => sum + node.paddedSize(), 0) : 0;
     const maxNeededIdx = preEditFromIdx + insertedContentSize;
     if (maxNeededIdx > tree.getSize()) {
       return void 0;
     }
     const topLevelRemoved = removedNodes.filter(
-      (node) => !node.parent || !removedNodes.includes(node.parent)
+      (node) => !preTombstoned.has(node.id.toIDString()) && (!node.parent || !removedNodes.includes(node.parent))
     );
-    const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map((n) => {
-      const clone = n.deepcopy();
-      clearRemovedAt(clone);
-      return clone;
-    }) : void 0;
+    const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map(
+      (n) => cloneAndDropPreTombstoned(n, preTombstoned)
+    ) : void 0;
     const reverseFromPos = tree.findPos(preEditFromIdx);
     let reverseToPos;
     if (insertedContentSize > 0) {
@@ -20097,6 +20228,11 @@ class Document {
       }
     ]);
   }
+  /**
+   * `clearHistory` flushes both undo and redo stacks. This is used
+   * after applying a snapshot or initialRoot so that setup operations
+   * are not reachable via undo.
+   */
   clearHistory() {
     this.internalHistory.clearRedo();
     this.internalHistory.clearUndo();
@@ -20556,10 +20692,7 @@ class Document {
     }
     const ops = isUndo ? this.internalHistory.popUndo() : this.internalHistory.popRedo();
     if (!ops) {
-      throw new YorkieError(
-        Code.ErrRefused,
-        `There is no operation to be ${isUndo ? "undone" : "redone"}`
-      );
+      return;
     }
     this.ensureClone();
     const ctx = ChangeContext.create(
@@ -20652,6 +20785,8 @@ class Attachment {
   syncMode;
   changeEventReceived;
   lastHeartbeatTime;
+  pollInterval;
+  pollIntervalPinned;
   reconnectStreamDelay;
   cancelled;
   watchStream;
@@ -20659,13 +20794,15 @@ class Attachment {
   watchAbortController;
   syncPromise;
   _detaching = false;
-  constructor(reconnectStreamDelay, resource, resourceID, syncMode) {
+  constructor(reconnectStreamDelay, resource, resourceID, syncMode, pollInterval = 0, pollIntervalPinned = false) {
     this.reconnectStreamDelay = reconnectStreamDelay;
     this.resource = resource;
     this.resourceID = resourceID;
     this.syncMode = syncMode;
     this.changeEventReceived = syncMode !== void 0 ? false : void 0;
     this.lastHeartbeatTime = Date.now();
+    this.pollInterval = pollInterval;
+    this.pollIntervalPinned = pollIntervalPinned;
     this.cancelled = false;
   }
   /**
@@ -20685,6 +20822,9 @@ class Attachment {
     if (this.syncMode === SyncMode.RealtimePushOnly) {
       return this.resource.hasLocalChanges();
     }
+    if (this.syncMode === SyncMode.Polling) {
+      return Date.now() - this.lastHeartbeatTime >= this.pollInterval;
+    }
     return this.syncMode !== SyncMode.Manual && (this.resource.hasLocalChanges() || (this.changeEventReceived ?? false));
   }
   /**
@@ -20698,7 +20838,8 @@ class Attachment {
     if (this.syncMode === SyncMode.Manual) {
       return false;
     }
-    return Date.now() - this.lastHeartbeatTime >= heartbeatInterval;
+    const interval = this.pollInterval > 0 ? this.pollInterval : heartbeatInterval;
+    return Date.now() - this.lastHeartbeatTime >= interval;
   }
   /**
    * `updateHeartbeatTime` updates the last heartbeat time.
@@ -20777,6 +20918,16 @@ class Attachment {
       }
     }
   }
+  /**
+   * `resetCancelled` clears the cancelled flag so the watch loop can run again
+   * after a previous cancellation (e.g., after changeSyncMode back to Realtime).
+   * Caller must invoke `runWatchLoop` immediately after to claim the stream slot;
+   * `doLoop`'s `if (this.watchStream)` guard prevents double-stream creation if a
+   * delayed `onDisconnect` callback from the previously-cancelled stream races.
+   */
+  resetCancelled() {
+    this.cancelled = false;
+  }
   /**
    * `cancelWatchStream` cancels the watch stream.
    */
@@ -20811,7 +20962,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.7.6";
+const version = "0.7.8";
 const pkg = {
   name,
   version
@@ -21094,6 +21245,7 @@ var SyncMode = /* @__PURE__ */ ((SyncMode2) => {
   SyncMode2["Realtime"] = "realtime";
   SyncMode2["RealtimePushOnly"] = "realtime-pushonly";
   SyncMode2["RealtimeSyncOff"] = "realtime-syncoff";
+  SyncMode2["Polling"] = "polling";
   return SyncMode2;
 })(SyncMode || {});
 var ClientStatus = /* @__PURE__ */ ((ClientStatus2) => {
@@ -21106,6 +21258,7 @@ var ClientCondition = /* @__PURE__ */ ((ClientCondition2) => {
   ClientCondition2["WatchLoop"] = "WatchLoop";
   return ClientCondition2;
 })(ClientCondition || {});
+const DefaultPollingIntervalMs = 3e3;
 const DefaultClientOptions = {
   rpcAddr: "https://api.yorkie.dev",
   syncLoopDuration: 50,
@@ -21301,6 +21454,14 @@ class Client {
     doc.setActor(this.id);
     doc.update((_, p) => p.set(opts.initialPresence || {}));
     const syncMode = opts.syncMode ?? "realtime";
+    if (opts.documentPollInterval !== void 0 && opts.documentPollInterval <= 0) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "documentPollInterval must be greater than 0"
+      );
+    }
+    const pollIntervalPinned = opts.documentPollInterval !== void 0;
+    const pollInterval = pollIntervalPinned ? opts.documentPollInterval : syncMode === "polling" ? DefaultPollingIntervalMs : 0;
     return this.enqueueTask(async () => {
       try {
         const res = await this.rpcClient.attachDocument(
@@ -21330,10 +21491,12 @@ class Client {
             this.reconnectStreamDelay,
             doc,
             res.documentId,
-            syncMode
+            syncMode,
+            pollInterval,
+            pollIntervalPinned
           )
         );
-        if (syncMode !== "manual") {
+        if (syncMode !== "manual" && syncMode !== "polling") {
           await this.runWatchLoop(doc.getKey());
         }
         logger.info(`[AD] c:"${this.getKey()}" attaches d:"${doc.getKey()}"`);
@@ -21349,6 +21512,7 @@ class Client {
             }
           });
         }
+        doc.clearHistory();
         return doc;
       } catch (err) {
         logger.error(`[AD] c:"${this.getKey()}" err :`, err);
@@ -21459,12 +21623,23 @@ class Client {
         channel.setSessionID(res.sessionId);
         channel.updateSessionCount(Number(res.sessionCount), 0);
         channel.applyStatus(ChannelStatus.Attached);
-        const syncMode = opts.isRealtime !== false ? "realtime" : "manual";
+        const syncMode = opts.syncMode ?? "realtime";
+        this.assertValidChannelSyncMode(syncMode);
+        if (opts.channelHeartbeatInterval !== void 0 && opts.channelHeartbeatInterval <= 0) {
+          throw new YorkieError(
+            Code.ErrInvalidArgument,
+            "channelHeartbeatInterval must be greater than 0"
+          );
+        }
+        const pollIntervalPinned = opts.channelHeartbeatInterval !== void 0;
+        const pollInterval = pollIntervalPinned ? opts.channelHeartbeatInterval : syncMode === "polling" ? DefaultPollingIntervalMs : this.channelHeartbeatInterval;
         const attachment = new Attachment(
           this.reconnectStreamDelay,
           channel,
           res.sessionId,
-          syncMode
+          syncMode,
+          pollInterval,
+          pollIntervalPinned
         );
         channel.subscribe("local-broadcast", (event) => {
           const { topic, payload, options } = event;
@@ -21540,9 +21715,17 @@ class Client {
     return this.enqueueTask(task);
   }
   /**
-   * `changeSyncMode` changes the synchronization mode of the given document.
+   * `changeSyncMode` changes the synchronization mode of the given resource.
    */
-  async changeSyncMode(doc, syncMode) {
+  async changeSyncMode(resource, syncMode) {
+    return this.enqueueTask(async () => {
+      if (resource instanceof Channel2) {
+        return this.changeChannelSyncMode(resource, syncMode);
+      }
+      return this.changeDocumentSyncMode(resource, syncMode);
+    });
+  }
+  async changeDocumentSyncMode(doc, syncMode) {
     if (!this.isActive()) {
       throw new YorkieError(
         Code.ErrClientNotActivated,
@@ -21560,19 +21743,66 @@ class Client {
     if (prevSyncMode === syncMode) {
       return doc;
     }
-    attachment.changeSyncMode(syncMode);
-    if (syncMode === "manual") {
+    if (syncMode === "manual" || syncMode === "polling") {
       attachment.cancelWatchStream();
-      return doc;
     }
+    attachment.changeSyncMode(syncMode);
     if (syncMode === "realtime") {
       attachment.changeEventReceived = true;
     }
-    if (prevSyncMode === "manual") {
+    if (!attachment.pollIntervalPinned) {
+      attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : 0;
+    }
+    if ((prevSyncMode === "manual" || prevSyncMode === "polling") && syncMode !== "manual" && syncMode !== "polling") {
+      attachment.resetCancelled();
       await this.runWatchLoop(doc.getKey());
     }
     return doc;
   }
+  /**
+   * `assertValidChannelSyncMode` rejects sync modes that are not valid for
+   * channels. `RealtimePushOnly` and `RealtimeSyncOff` are document-only.
+   */
+  assertValidChannelSyncMode(syncMode) {
+    if (syncMode !== "manual" && syncMode !== "realtime" && syncMode !== "polling") {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `invalid channel sync mode: ${syncMode}`
+      );
+    }
+  }
+  async changeChannelSyncMode(channel, syncMode) {
+    if (!this.isActive()) {
+      throw new YorkieError(
+        Code.ErrClientNotActivated,
+        `${this.key} is not active`
+      );
+    }
+    const attachment = this.attachmentMap.get(channel.getKey());
+    if (!attachment) {
+      throw new YorkieError(
+        Code.ErrNotAttached,
+        `${channel.getKey()} is not attached`
+      );
+    }
+    const prevSyncMode = attachment.syncMode;
+    if (prevSyncMode === syncMode) {
+      return channel;
+    }
+    this.assertValidChannelSyncMode(syncMode);
+    if (prevSyncMode === "realtime") {
+      attachment.cancelWatchStream();
+    }
+    attachment.changeSyncMode(syncMode);
+    if (!attachment.pollIntervalPinned) {
+      attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : syncMode === "realtime" ? this.channelHeartbeatInterval : 0;
+    }
+    if (syncMode === "realtime") {
+      attachment.resetCancelled();
+      await this.runWatchLoop(channel.getKey());
+    }
+    return channel;
+  }
   /**
    * `sync` implementation that handles both Document and Channel.
    */
@@ -22417,6 +22647,7 @@ class Client {
         return doc;
       }
       doc.applyChangePack(respPack);
+      attachment.updateHeartbeatTime();
       attachment.resource.publish([
         {
           type: DocEventType.SyncStatusChanged,
@@ -22527,8 +22758,11 @@ function isBinData(value) {
 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 {
@@ -22544,6 +22778,12 @@ function parse(yson) {
 }
 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) => {
@@ -22604,6 +22844,20 @@ function postprocessValue(value) {
       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")) {
@@ -22692,6 +22946,7 @@ const YSON = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty
   isBinData,
   isCounter,
   isDate,
+  isDedupCounter,
   isInt,
   isLong,
   isObject,