@liveblocks/core 3.24.2 → 3.24.3

package/dist/index.cjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.24.2";
+var PKG_VERSION = "3.24.3";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -9850,6 +9850,10 @@ var LiveText = class _LiveText extends AbstractCrdt {
   /** Local edits made while an op is in flight; sent after the ack. */
   #queuedOps = [];
   #acceptedOps = [];
+  /** Wait for replay history before applying post-snapshot remote ops. */
+  #reconnecting = false;
+  #deferredHistorylessAck = false;
+  #bufferedRemoteOps = [];
   /**
    * Creates a new LiveText document.
    *
@@ -9921,6 +9925,14 @@ var LiveText = class _LiveText extends AbstractCrdt {
     throw new Error("LiveText cannot contain child nodes");
   }
   /** @internal */
+  _deferAckWithoutHistory(op) {
+    if (this.#reconnecting && !this.#deferredHistorylessAck && op.opId !== void 0 && op.opId === this.#inFlightOpId && op.history === void 0) {
+      this.#deferredHistorylessAck = true;
+      return true;
+    }
+    return false;
+  }
+  /** @internal */
   _apply(op, source) {
     if (op.type !== OpCode.UPDATE_TEXT) {
       return super._apply(op, source);
@@ -10152,8 +10164,6 @@ var LiveText = class _LiveText extends AbstractCrdt {
   #applyLocal(op, source) {
     const mutableOp = op;
     if (op.opId !== void 0 && op.opId === this.#inFlightOpId) {
-      this.#inFlightOps = [...this.#inFlightOps, ...this.#queuedOps];
-      this.#queuedOps = [];
       mutableOp.baseVersion = this.#version;
       mutableOp.ops = [...this.#inFlightOps];
       return { modified: false };
@@ -10192,6 +10202,9 @@ var LiveText = class _LiveText extends AbstractCrdt {
   }
   /** Server acknowledgement of our in-flight op. */
   #applyAck(op, source) {
+    if (this.#reconnecting) {
+      return this.#reconcileAck(op, source);
+    }
     const ackedVersion = _nullishCoalesce(op.version, () => ( Math.max(this.#version, op.baseVersion + 1)));
     const predicted = this.#inFlightOps;
     const opId = this.#inFlightOpId;
@@ -10214,7 +10227,9 @@ var LiveText = class _LiveText extends AbstractCrdt {
             node: this,
             version: ackedVersion,
             updates: rebuilt.changes,
-            source
+            // A correction was not applied by the originating editor. It
+            // must not be filtered out as an echo of a local edit.
+            source: REMOTE
           }
         };
       }
@@ -10224,9 +10239,69 @@ var LiveText = class _LiveText extends AbstractCrdt {
     this.#flushQueued();
     return result;
   }
+  /** Recover the missing server timeline, preserving the normal OT invariants. */
+  #reconcileAck(op, source) {
+    const history = op.history;
+    if (history === void 0) {
+      this._rejectPendingOp(nn(op.opId));
+      return { modified: false, needsStorageResync: true };
+    }
+    this.#reconnecting = false;
+    this.#deferredHistorylessAck = false;
+    const buffered = this.#bufferedRemoteOps;
+    this.#bufferedRemoteOps = [];
+    const changes = [];
+    const collect = (result) => {
+      if (result.modified && result.modified.type === "LiveText") {
+        changes.push(...result.modified.updates);
+      }
+    };
+    for (const entry of history) {
+      if (entry.version <= this.#version) continue;
+      if (entry.version === op.version) {
+        collect(this.#applyAck(op, source));
+      } else {
+        collect(
+          this.#applyRemote(
+            {
+              type: OpCode.UPDATE_TEXT,
+              id: op.id,
+              baseVersion: entry.version - 1,
+              version: entry.version,
+              ops: entry.ops
+            },
+            REMOTE
+          )
+        );
+      }
+    }
+    if (this.#inFlightOpId === op.opId) {
+      collect(this.#applyAck(op, source));
+    }
+    for (const remote of buffered) {
+      collect(this.#applyRemote(remote, REMOTE));
+    }
+    return changes.length === 0 ? { modified: false } : {
+      reverse: [],
+      modified: {
+        type: "LiveText",
+        node: this,
+        version: this.#version,
+        updates: changes,
+        source: REMOTE
+      }
+    };
+  }
   /** An accepted op from another client (or a server-fabricated fix op). */
   #applyRemote(op, source) {
     const version = _nullishCoalesce(op.version, () => ( this.#version + 1));
+    if (op.version !== void 0 && op.version <= this.#version) {
+      return { modified: false };
+    }
+    if (this.#reconnecting) {
+      this.#bufferedRemoteOps.push(op);
+      return { modified: false };
+    }
     this.#confirmed = applyTextOperationsToSegments(this.#confirmed, op.ops);
     const [overInFlight, inFlight] = transformTextOperationsX(
       op.ops,
@@ -10332,14 +10407,18 @@ var LiveText = class _LiveText extends AbstractCrdt {
     return { appliedOps, changes };
   }
   /**
-   * Reconcile this node against an authoritative storage snapshot (e.g.
-   * after a reconnect). The confirmed state and version are replaced by the
-   * snapshot's; pending (in-flight + queued) ops are preserved on top and
-   * will be re-sent by the offline-ops replay.
+   * Reconcile against an authoritative snapshot. With pending edits, retain
+   * the current document and confirmed version until replay history arrives:
+   * a snapshot alone cannot re-express the queue over unseen operations.
    *
    * @internal
    */
   _resyncText(data, version, source) {
+    if (this.#inFlightOpId !== void 0) {
+      this.#reconnecting = true;
+      this.#deferredHistorylessAck = false;
+      return void 0;
+    }
     this.#confirmed = dataToSegments(data);
     this.#version = version;
     this.#acceptedOps = [];
@@ -10369,6 +10448,9 @@ var LiveText = class _LiveText extends AbstractCrdt {
     this.#inFlightOpId = void 0;
     this.#inFlightOps = [];
     this.#queuedOps = [];
+    this.#bufferedRemoteOps = [];
+    this.#reconnecting = false;
+    this.#deferredHistorylessAck = false;
   }
   #recordAccepted(version, ops, opId) {
     if (this.#acceptedOps.some((entry) => entry.version === version)) {
@@ -12303,6 +12385,12 @@ function createRoom(options, config) {
     }
     const createdNodeIds = /* @__PURE__ */ new Set();
     for (const op of ops) {
+      if (!isLocal && op.type === OpCode.UPDATE_TEXT && op.opId !== void 0) {
+        const node = context.pool.nodes.get(op.id);
+        if (node !== void 0 && isLiveText(node) && node._deferAckWithoutHistory(op)) {
+          continue;
+        }
+      }
       let source;
       if (isLocal) {
         source = { ...localSource, optimistic: true };
@@ -12317,6 +12405,10 @@ function createRoom(options, config) {
         source = REMOTE;
       }
       const applyOpResult = applyOp(op, source);
+      if ("needsStorageResync" in applyOpResult) {
+        refreshStorage();
+        flushNowOrSoon();
+      }
       if (applyOpResult.modified) {
         const nodeId = applyOpResult.modified.node._id;
         if (!(nodeId && createdNodeIds.has(nodeId))) {
@@ -12537,7 +12629,8 @@ function createRoom(options, config) {
     const result = applyLocalOps(unackedOps);
     messages.push({
       type: ClientMsgCode.UPDATE_STORAGE,
-      ops: result.opsToEmit
+      ops: result.opsToEmit,
+      includeTextHistory: true
     });
     notify(result.updates);
     sendMessages(messages);