@liveblocks/core 3.24.2 → 3.24.3-livetextreplay

package/dist/index.d.cts

@@ -431,6 +431,11 @@ type UpdateTextOp = {
     readonly baseVersion: number;
     readonly version?: number;
     readonly ops: TextOperation[];
+    /** Server-only: accepted ops after the requested base version when reconciling. */
+    readonly history?: {
+        readonly version: number;
+        readonly ops: TextOperation[];
+    }[];
 };
 type DeleteCrdtOp = {
     readonly opId?: string;
@@ -970,6 +975,13 @@ type PrivateLiveTextApi = PrivateLiveNodeApi & {
  * the pending ops are re-expressed over the remote op in turn ("after"
  * order), keeping them in server coordinates at all times.
  *
+ * Reconnect replay: keep the pre-disconnect confirmed state and re-send only
+ * the in-flight op at that version. The server returns the intervening
+ * accepted operations with its acknowledgement, including the original op
+ * if it was already stored. Replaying that history through the normal OT
+ * paths rebases the pending edits exactly, without applying them twice to a
+ * snapshot. Queued edits stay queued until their predecessor is acknowledged.
+ *
  * @example
  * const text = new LiveText("Hello");
  * text.insert(5, " world");
@@ -3189,6 +3201,8 @@ type UpdatePresenceClientMsg<P extends JsonObject> = {
 type UpdateStorageClientMsg = {
     readonly type: ClientMsgCode.UPDATE_STORAGE;
     readonly ops: ClientWireOp[];
+    /** Include authoritative history in text acknowledgements after a storage resync. */
+    readonly includeTextHistory?: true;
 };
 type FetchStorageClientMsg = {
     readonly type: ClientMsgCode.FETCH_STORAGE;

package/dist/index.d.ts

@@ -431,6 +431,11 @@ type UpdateTextOp = {
     readonly baseVersion: number;
     readonly version?: number;
     readonly ops: TextOperation[];
+    /** Server-only: accepted ops after the requested base version when reconciling. */
+    readonly history?: {
+        readonly version: number;
+        readonly ops: TextOperation[];
+    }[];
 };
 type DeleteCrdtOp = {
     readonly opId?: string;
@@ -970,6 +975,13 @@ type PrivateLiveTextApi = PrivateLiveNodeApi & {
  * the pending ops are re-expressed over the remote op in turn ("after"
  * order), keeping them in server coordinates at all times.
  *
+ * Reconnect replay: keep the pre-disconnect confirmed state and re-send only
+ * the in-flight op at that version. The server returns the intervening
+ * accepted operations with its acknowledgement, including the original op
+ * if it was already stored. Replaying that history through the normal OT
+ * paths rebases the pending edits exactly, without applying them twice to a
+ * snapshot. Queued edits stay queued until their predecessor is acknowledged.
+ *
  * @example
  * const text = new LiveText("Hello");
  * text.insert(5, " world");
@@ -3189,6 +3201,8 @@ type UpdatePresenceClientMsg<P extends JsonObject> = {
 type UpdateStorageClientMsg = {
     readonly type: ClientMsgCode.UPDATE_STORAGE;
     readonly ops: ClientWireOp[];
+    /** Include authoritative history in text acknowledgements after a storage resync. */
+    readonly includeTextHistory?: true;
 };
 type FetchStorageClientMsg = {
     readonly type: ClientMsgCode.FETCH_STORAGE;

package/dist/index.js

@@ -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-livetextreplay";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -9850,6 +9850,9 @@ 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;
+  #bufferedRemoteOps = [];
   /**
    * Creates a new LiveText document.
    *
@@ -10152,8 +10155,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 +10193,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 = op.version ?? Math.max(this.#version, op.baseVersion + 1);
     const predicted = this.#inFlightOps;
     const opId = this.#inFlightOpId;
@@ -10214,7 +10218,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 +10230,67 @@ 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 = nn(
+      op.history,
+      "LiveText replay acknowledgement requires history"
+    );
+    this.#reconnecting = 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 = 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 +10396,17 @@ 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;
+      return void 0;
+    }
     this.#confirmed = dataToSegments(data);
     this.#version = version;
     this.#acceptedOps = [];
@@ -10369,6 +10436,8 @@ var LiveText = class _LiveText extends AbstractCrdt {
     this.#inFlightOpId = void 0;
     this.#inFlightOps = [];
     this.#queuedOps = [];
+    this.#bufferedRemoteOps = [];
+    this.#reconnecting = false;
   }
   #recordAccepted(version, ops, opId) {
     if (this.#acceptedOps.some((entry) => entry.version === version)) {
@@ -12537,7 +12606,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);