@liveblocks/core 3.20.0-exp7 → 3.20.0-exp8

package/dist/index.cjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.20.0-exp7";
+var PKG_VERSION = "3.20.0-exp8";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -5519,7 +5519,7 @@ function isIgnoredOp(op) {
   return op.type === OpCode.DELETE_CRDT && op.id === "ACK";
 }
 function isCreateOp(op) {
-  return op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_REGISTER || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_LIST;
+  return op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_REGISTER || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_TEXT;
 }
 
 // src/protocol/StorageNode.ts
@@ -5814,6 +5814,10 @@ ${parentKey}`;
   get size() {
     return this.#byOpId.size;
   }
+  /** The still-unacknowledged op with the given opId, if any. */
+  get(opId) {
+    return this.#byOpId.get(opId);
+  }
   /**
    * Mark the given Op as still unacknowledged.
    */
@@ -5914,8 +5918,8 @@ function createManagedPool(roomId, options) {
     deleteNode: (id) => void nodes.delete(id),
     generateId: () => `${getCurrentConnectionId()}:${clock++}`,
     generateOpId: () => `${getCurrentConnectionId()}:${opClock++}`,
-    dispatch(ops, reverse, storageUpdates) {
-      _optionalChain([onDispatch, 'optionalCall', _125 => _125(ops, reverse, storageUpdates)]);
+    dispatch(ops, reverse, storageUpdates, options2) {
+      _optionalChain([onDispatch, 'optionalCall', _125 => _125(ops, reverse, storageUpdates, options2)]);
     },
     assertStorageIsWritable: () => {
       if (!isStorageWritable()) {
@@ -8674,43 +8678,171 @@ function formatReverseOperations(segments, index, length, patch) {
   }
   return result;
 }
-function mapIndexThroughOperation(index, op) {
-  if (op.type === "insert") {
-    return op.index <= index ? index + op.text.length : index;
-  } else if (op.type === "delete") {
-    if (op.index >= index) {
-      return index;
-    }
-    return Math.max(op.index, index - op.length);
-  } else {
+function oppositeOrder(order) {
+  return order === "before" ? "after" : "before";
+}
+function mapIndexOverDelete(index, deleteIndex, deleteLength) {
+  if (deleteIndex >= index) {
     return index;
   }
+  return Math.max(deleteIndex, index - deleteLength);
 }
-function mapTextIndexThroughOperations(index, ops) {
-  let mapped = index;
-  for (const op of ops) {
-    mapped = mapIndexThroughOperation(mapped, op);
+function transformInsert(op, over, order) {
+  if (over.type === "insert") {
+    const shifts = over.index < op.index || over.index === op.index && order === "after";
+    return [shifts ? { ...op, index: op.index + over.text.length } : { ...op }];
+  } else if (over.type === "delete") {
+    return [
+      { ...op, index: mapIndexOverDelete(op.index, over.index, over.length) }
+    ];
+  } else {
+    return [{ ...op }];
   }
-  return mapped;
 }
-function rebaseTextOperations(ops, acceptedOps) {
-  return ops.map((op) => {
-    if (op.type === "insert") {
-      return {
-        ...op,
-        index: mapTextIndexThroughOperations(op.index, acceptedOps)
-      };
-    } else if (op.type === "delete" || op.type === "format") {
-      const start = mapTextIndexThroughOperations(op.index, acceptedOps);
-      const end = mapTextIndexThroughOperations(
-        op.index + op.length,
-        acceptedOps
-      );
-      return { ...op, index: start, length: Math.max(0, end - start) };
-    } else {
-      return op;
+function transformDelete(op, over) {
+  const start = op.index;
+  const end = op.index + op.length;
+  if (over.type === "insert") {
+    const at = over.index;
+    const len = over.text.length;
+    if (at <= start) {
+      return [{ ...op, index: start + len }];
     }
-  });
+    if (at >= end) {
+      return [{ ...op }];
+    }
+    return [
+      { type: "delete", index: start, length: at - start },
+      { type: "delete", index: start + len, length: end - at }
+    ];
+  } else if (over.type === "delete") {
+    const newStart = mapIndexOverDelete(start, over.index, over.length);
+    const newEnd = mapIndexOverDelete(end, over.index, over.length);
+    return newEnd - newStart > 0 ? [{ type: "delete", index: newStart, length: newEnd - newStart }] : [];
+  } else {
+    return [{ ...op }];
+  }
+}
+function transformFormat(op, over, order) {
+  const start = op.index;
+  const end = op.index + op.length;
+  if (over.type === "insert") {
+    const at = over.index;
+    const len = over.text.length;
+    if (at <= start) {
+      return [{ ...op, index: start + len }];
+    }
+    if (at >= end) {
+      return [{ ...op }];
+    }
+    return [
+      {
+        type: "format",
+        index: start,
+        length: at - start,
+        attributes: op.attributes
+      },
+      {
+        type: "format",
+        index: at + len,
+        length: end - at,
+        attributes: op.attributes
+      }
+    ];
+  } else if (over.type === "delete") {
+    const newStart = mapIndexOverDelete(start, over.index, over.length);
+    const newEnd = mapIndexOverDelete(end, over.index, over.length);
+    return newEnd - newStart > 0 ? [
+      {
+        type: "format",
+        index: newStart,
+        length: newEnd - newStart,
+        attributes: op.attributes
+      }
+    ] : [];
+  } else {
+    if (order === "after") {
+      return [{ ...op }];
+    }
+    const overlapStart = Math.max(start, over.index);
+    const overlapEnd = Math.min(end, over.index + over.length);
+    if (overlapStart >= overlapEnd) {
+      return [{ ...op }];
+    }
+    const hasConflict = Object.keys(op.attributes).some(
+      (key) => key in over.attributes
+    );
+    if (!hasConflict) {
+      return [{ ...op }];
+    }
+    const reduced = {};
+    for (const [key, value] of Object.entries(op.attributes)) {
+      if (!(key in over.attributes)) {
+        reduced[key] = value;
+      }
+    }
+    const pieces = [];
+    if (start < overlapStart) {
+      pieces.push({
+        type: "format",
+        index: start,
+        length: overlapStart - start,
+        attributes: op.attributes
+      });
+    }
+    if (Object.keys(reduced).length > 0) {
+      pieces.push({
+        type: "format",
+        index: overlapStart,
+        length: overlapEnd - overlapStart,
+        attributes: reduced
+      });
+    }
+    if (overlapEnd < end) {
+      pieces.push({
+        type: "format",
+        index: overlapEnd,
+        length: end - overlapEnd,
+        attributes: op.attributes
+      });
+    }
+    return pieces;
+  }
+}
+function transformSingle(op, over, order) {
+  switch (op.type) {
+    case "insert":
+      return transformInsert(op, over, order);
+    case "delete":
+      return transformDelete(op, over);
+    case "format":
+      return transformFormat(op, over, order);
+  }
+}
+function transformTextOperationsX(a, b, order) {
+  if (a.length === 0 || b.length === 0) {
+    return [[...a], [...b]];
+  }
+  if (a.length === 1 && b.length === 1) {
+    return [
+      transformSingle(a[0], b[0], order),
+      transformSingle(b[0], a[0], oppositeOrder(order))
+    ];
+  }
+  if (a.length > 1) {
+    const [headA1, b1] = transformTextOperationsX([a[0]], b, order);
+    const [restA1, b2] = transformTextOperationsX(a.slice(1), b1, order);
+    return [[...headA1, ...restA1], b2];
+  }
+  const [a1, headB1] = transformTextOperationsX(a, [b[0]], order);
+  const [a2, restB1] = transformTextOperationsX(a1, b.slice(1), order);
+  return [a2, [...headB1, ...restB1]];
+}
+function transformTextOperations(ops, over, order) {
+  return transformTextOperationsX(ops, over, order)[0];
+}
+function textOperationsEqual(a, b) {
+  return a === b || stableStringify(a) === stableStringify(b);
 }
 function applyTextOperationsToSegments(segments, ops) {
   let next = [...segments];
@@ -8782,21 +8914,31 @@ function invertTextOperations(segments, ops) {
 }
 
 // src/crdts/LiveText.ts
+var ACCEPTED_OPS_HISTORY_LIMIT = 1e3;
 var LiveText = class _LiveText extends AbstractCrdt {
+  /** The local document: #confirmed ⊕ #inFlightOps ⊕ #queuedOps. */
   #segments;
+  /** The server-confirmed document (only authoritative ops applied). */
+  #confirmed;
   #version;
-  #pendingOps;
+  /** The op currently awaiting server acknowledgement (at most one). */
+  #inFlightOpId;
+  /** Its ops, continuously re-expressed against current server state. */
+  #inFlightOps = [];
+  /** Local edits made while an op is in flight; sent after the ack. */
+  #queuedOps = [];
+  #acceptedOps = [];
   constructor(textOrData = "", version = 0) {
     super();
     this.#segments = typeof textOrData === "string" ? textOrData.length === 0 ? [] : [{ text: textOrData }] : dataToSegments(textOrData);
+    this.#confirmed = [...this.#segments];
     this.#version = version;
-    this.#pendingOps = /* @__PURE__ */ new Map();
   }
   get version() {
     return this.#version;
   }
   get length() {
-    return this.toString().length;
+    return textLength(this.#segments);
   }
   /** @internal */
   static _deserialize([id, item], _parentToChildren, pool) {
@@ -8847,30 +8989,16 @@ var LiveText = class _LiveText extends AbstractCrdt {
       return super._apply(op, isLocal);
     }
     if (isLocal) {
-      this.#pendingOps.set(nn(op.opId), op.ops);
-      return this.#applyOperations(op.ops, _nullishCoalesce(op.version, () => ( this.#version)));
-    }
-    if (op.opId !== void 0) {
-      const pending2 = this.#pendingOps.get(op.opId);
-      this.#pendingOps.delete(op.opId);
-      const otherPending = Array.from(this.#pendingOps.values()).flat();
-      if (pending2 !== void 0 && otherPending.length > 0) {
-        this.#segments = applyTextOperationsToSegments(
-          this.#segments,
-          invertTextOperations(this.#segments, pending2)
-        );
-        const ops2 = rebaseTextOperations(op.ops, otherPending);
-        return this.#applyOperations(
-          ops2,
-          _nullishCoalesce(op.version, () => ( Math.max(this.#version, op.baseVersion + 1)))
-        );
-      }
-      this.#version = _nullishCoalesce(op.version, () => ( Math.max(this.#version, op.baseVersion + 1)));
+      return this.#applyLocal(op);
+    }
+    if (op.opId !== void 0 && op.opId === this.#inFlightOpId) {
+      return this.#applyAck(op);
+    }
+    if (op.opId !== void 0 && this.#acceptedOps.some((entry) => entry.opId === op.opId)) {
+      this.#version = Math.max(this.#version, _nullishCoalesce(op.version, () => ( op.baseVersion + 1)));
       return { modified: false };
     }
-    const pending = Array.from(this.#pendingOps.values()).flat();
-    const ops = pending.length > 0 ? rebaseTextOperations(op.ops, pending) : op.ops;
-    return this.#applyOperations(ops, _nullishCoalesce(op.version, () => ( this.#version + 1)));
+    return this.#applyRemote(op);
   }
   insert(index, text, attributes) {
     const clippedIndex = Math.max(0, Math.min(index, this.length));
@@ -8914,45 +9042,153 @@ var LiveText = class _LiveText extends AbstractCrdt {
       }
     ]);
   }
+  /** Local edits made through the public API. */
   #dispatch(ops) {
     if (ops.length === 0) {
       return;
     }
     _optionalChain([this, 'access', _215 => _215._pool, 'optionalAccess', _216 => _216.assertStorageIsWritable, 'call', _217 => _217()]);
-    const baseVersion = this.#version;
-    const reverse = this._pool !== void 0 && this._id !== void 0 ? this.#invertOperations(ops) : [];
+    const attached = this._pool !== void 0 && this._id !== void 0;
+    const reverse = attached ? this.#invertOperations(ops) : [];
     const changes = this.#applyOperationsLocally(ops);
-    if (this._pool !== void 0 && this._id !== void 0) {
-      const opId = this._pool.generateOpId();
-      this.#pendingOps.set(opId, ops);
-      this._pool.dispatch(
+    if (!attached) {
+      return;
+    }
+    const pool = nn(this._pool);
+    const id = nn(this._id);
+    const updates = /* @__PURE__ */ new Map([
+      [
+        id,
+        {
+          type: "LiveText",
+          node: this,
+          version: this.#version,
+          updates: changes
+        }
+      ]
+    ]);
+    if (this.#inFlightOpId === void 0) {
+      const opId = pool.generateOpId();
+      this.#inFlightOpId = opId;
+      this.#inFlightOps = [...ops];
+      pool.dispatch(
         [
           {
             type: OpCode.UPDATE_TEXT,
-            id: this._id,
+            id,
             opId,
-            baseVersion,
+            baseVersion: this.#version,
             ops: [...ops]
           }
         ],
         reverse,
-        /* @__PURE__ */ new Map([
-          [
-            this._id,
-            {
-              type: "LiveText",
-              node: this,
-              version: this.#version,
-              updates: changes
-            }
-          ]
-        ])
+        updates
       );
+    } else {
+      this.#queuedOps.push(...ops);
+      pool.dispatch([], reverse, updates, { clearRedoStack: true });
     }
   }
-  #applyOperations(ops, version) {
+  /**
+   * A local replay of an existing wire op: an undo/redo frame, or an
+   * unacknowledged op re-sent after a reconnect.
+   */
+  #applyLocal(op) {
+    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 };
+    }
+    let ops = op.ops;
+    for (const entry of this.#acceptedOps) {
+      if (entry.version > op.baseVersion && entry.ops.length > 0) {
+        ops = transformTextOperations(ops, entry.ops, "after");
+      }
+    }
     const reverse = this.#invertOperations(ops);
     const changes = this.#applyOperationsLocally(ops);
+    if (this.#inFlightOpId === void 0 && ops.length > 0) {
+      this.#inFlightOpId = nn(op.opId, "Local ops must have an opId");
+      this.#inFlightOps = [...ops];
+      mutableOp.baseVersion = this.#version;
+      mutableOp.ops = [...ops];
+    } else {
+      this.#queuedOps.push(...ops);
+      mutableOp.baseVersion = this.#version;
+      mutableOp.ops = [];
+    }
+    if (changes.length === 0) {
+      return { modified: false };
+    }
+    return {
+      reverse,
+      modified: {
+        type: "LiveText",
+        node: this,
+        version: this.#version,
+        updates: changes
+      }
+    };
+  }
+  /** Server acknowledgement of our in-flight op. */
+  #applyAck(op) {
+    const ackedVersion = _nullishCoalesce(op.version, () => ( Math.max(this.#version, op.baseVersion + 1)));
+    const predicted = this.#inFlightOps;
+    const opId = this.#inFlightOpId;
+    this.#confirmed = applyTextOperationsToSegments(this.#confirmed, op.ops);
+    this.#inFlightOpId = void 0;
+    this.#inFlightOps = [];
+    let appliedOps = [];
+    let result = { modified: false };
+    if (!textOperationsEqual(op.ops, predicted)) {
+      error2(
+        "LiveText: acknowledgement did not match the local prediction; resynchronizing"
+      );
+      const rebuilt = this.#rebuildLocalFromConfirmed();
+      appliedOps = rebuilt.appliedOps;
+      if (rebuilt.changes.length > 0) {
+        result = {
+          reverse: [],
+          modified: {
+            type: "LiveText",
+            node: this,
+            version: ackedVersion,
+            updates: rebuilt.changes
+          }
+        };
+      }
+    }
+    this.#version = Math.max(this.#version, ackedVersion);
+    this.#recordAccepted(ackedVersion, appliedOps, opId);
+    this.#flushQueued();
+    return result;
+  }
+  /** An accepted op from another client (or a server-fabricated fix op). */
+  #applyRemote(op) {
+    const version = _nullishCoalesce(op.version, () => ( this.#version + 1));
+    this.#confirmed = applyTextOperationsToSegments(this.#confirmed, op.ops);
+    const [overInFlight, inFlight] = transformTextOperationsX(
+      op.ops,
+      this.#inFlightOps,
+      "before"
+    );
+    const [applied, queued] = transformTextOperationsX(
+      overInFlight,
+      this.#queuedOps,
+      "before"
+    );
+    this.#inFlightOps = inFlight;
+    this.#queuedOps = queued;
+    this.#recordAccepted(version, applied, op.opId);
+    if (applied.length === 0) {
+      this.#version = Math.max(this.#version, version);
+      return { modified: false };
+    }
+    const reverse = this.#invertOperations(applied);
+    const changes = this.#applyOperationsLocally(applied);
     this.#version = Math.max(this.#version, version);
     return {
       reverse,
@@ -8964,6 +9200,129 @@ var LiveText = class _LiveText extends AbstractCrdt {
       }
     };
   }
+  /** Send the queued ops as the next in-flight op (after an ack). */
+  #flushQueued() {
+    if (this.#queuedOps.length === 0 || this._pool === void 0 || this._id === void 0) {
+      return;
+    }
+    const opId = this._pool.generateOpId();
+    this.#inFlightOpId = opId;
+    this.#inFlightOps = this.#queuedOps;
+    this.#queuedOps = [];
+    this._pool.dispatch(
+      [
+        {
+          type: OpCode.UPDATE_TEXT,
+          id: this._id,
+          opId,
+          baseVersion: this.#version,
+          ops: [...this.#inFlightOps]
+        }
+      ],
+      [],
+      /* @__PURE__ */ new Map(),
+      // The local content was already applied (and made undoable) when the
+      // edits happened; this is purely an outbound flush.
+      { clearRedoStack: false }
+    );
+  }
+  /**
+   * Rebuild the local document as confirmed ⊕ queued ops, returning the
+   * coarse delta that was applied. Only used by defensive recovery paths.
+   */
+  #rebuildLocalFromConfirmed() {
+    const before2 = this.#segments;
+    const after2 = applyTextOperationsToSegments(this.#confirmed, [
+      ...this.#inFlightOps,
+      ...this.#queuedOps
+    ]);
+    if (stableStringify(segmentsToData(before2)) === stableStringify(segmentsToData(after2))) {
+      this.#segments = after2;
+      return { appliedOps: [], changes: [] };
+    }
+    const beforeText = before2.map((segment) => segment.text).join("");
+    this.#segments = after2;
+    this.invalidate();
+    const appliedOps = [];
+    const changes = [];
+    if (beforeText.length > 0) {
+      appliedOps.push({ type: "delete", index: 0, length: beforeText.length });
+      changes.push({
+        type: "delete",
+        index: 0,
+        length: beforeText.length,
+        deletedText: beforeText
+      });
+    }
+    let index = 0;
+    for (const segment of after2) {
+      appliedOps.push({
+        type: "insert",
+        index,
+        text: segment.text,
+        attributes: segment.attributes
+      });
+      changes.push({
+        type: "insert",
+        index,
+        text: segment.text,
+        attributes: segment.attributes
+      });
+      index += segment.text.length;
+    }
+    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.
+   *
+   * @internal
+   */
+  _resyncText(data, version) {
+    this.#confirmed = dataToSegments(data);
+    this.#version = version;
+    this.#acceptedOps = [];
+    const rebuilt = this.#rebuildLocalFromConfirmed();
+    if (rebuilt.changes.length === 0) {
+      return void 0;
+    }
+    return {
+      type: "LiveText",
+      node: this,
+      version: this.#version,
+      updates: rebuilt.changes
+    };
+  }
+  /**
+   * Called when the server rejected one of our ops. Drops all pending state
+   * for this node (edits queued behind a rejected op cannot be trusted
+   * either); the room follows up with a storage resync.
+   *
+   * @internal
+   */
+  _rejectPendingOp(opId) {
+    if (opId !== this.#inFlightOpId) {
+      return;
+    }
+    this.#inFlightOpId = void 0;
+    this.#inFlightOps = [];
+    this.#queuedOps = [];
+  }
+  #recordAccepted(version, ops, opId) {
+    if (this.#acceptedOps.some((entry) => entry.version === version)) {
+      return;
+    }
+    this.#acceptedOps.push({ version, opId, ops: [...ops] });
+    this.#acceptedOps.sort((left, right) => left.version - right.version);
+    if (this.#acceptedOps.length > ACCEPTED_OPS_HISTORY_LIMIT) {
+      this.#acceptedOps.splice(
+        0,
+        this.#acceptedOps.length - ACCEPTED_OPS_HISTORY_LIMIT
+      );
+    }
+  }
   #applyOperationsLocally(ops) {
     const changes = [];
     for (const op of ops) {
@@ -9236,40 +9595,6 @@ function getTreesDiffOperations(currentItems, newItems) {
           }
         }
       }
-      if (crdt.type === CrdtType.TEXT) {
-        if (currentCrdt.type !== CrdtType.TEXT || stringifyOrLog(crdt.data) !== stringifyOrLog(currentCrdt.data) || crdt.version !== currentCrdt.version) {
-          ops.push({
-            type: OpCode.UPDATE_TEXT,
-            id,
-            baseVersion: currentCrdt.type === CrdtType.TEXT ? currentCrdt.version : 0,
-            version: crdt.version,
-            ops: [
-              {
-                type: "delete",
-                index: 0,
-                length: currentCrdt.type === CrdtType.TEXT ? currentCrdt.data.reduce(
-                  (sum, segment) => sum + segment[0].length,
-                  0
-                ) : 0
-              },
-              ...crdt.data.map((segment, index, items) => {
-                const [text, attributes] = segment;
-                const insertIndex = items.slice(0, index).reduce((sum, item) => sum + item[0].length, 0);
-                return attributes === void 0 ? {
-                  type: "insert",
-                  index: insertIndex,
-                  text
-                } : {
-                  type: "insert",
-                  index: insertIndex,
-                  text,
-                  attributes
-                };
-              })
-            ]
-          });
-        }
-      }
       if (crdt.parentKey !== currentCrdt.parentKey) {
         ops.push({
           type: OpCode.SET_PARENT_KEY,
@@ -10400,7 +10725,7 @@ function createRoom(options, config) {
       }
     }
   });
-  function onDispatch(ops, reverse, storageUpdates) {
+  function onDispatch(ops, reverse, storageUpdates, options2) {
     if (context.activeBatch) {
       for (const op of ops) {
         context.activeBatch.ops.push(op);
@@ -10419,15 +10744,17 @@ function createRoom(options, config) {
       if (reverse.length > 0) {
         addToUndoStack(reverse);
       }
-      if (ops.length > 0) {
+      if (_nullishCoalesce(_optionalChain([options2, 'optionalAccess', _229 => _229.clearRedoStack]), () => ( ops.length > 0))) {
         context.redoStack.length = 0;
+      }
+      if (ops.length > 0) {
         dispatchOps(ops);
       }
       notify({ storageUpdates });
     }
   }
   function isStorageWritable() {
-    const scopes = _optionalChain([context, 'access', _229 => _229.dynamicSessionInfoSig, 'access', _230 => _230.get, 'call', _231 => _231(), 'optionalAccess', _232 => _232.scopes]);
+    const scopes = _optionalChain([context, 'access', _230 => _230.dynamicSessionInfoSig, 'access', _231 => _231.get, 'call', _232 => _232(), 'optionalAccess', _233 => _233.scopes]);
     return scopes !== void 0 ? canWriteStorage(scopes) : true;
   }
   const eventHub = {
@@ -10524,6 +10851,23 @@ function createRoom(options, config) {
       }
       const ops = getTreesDiffOperations(currentItems, nodes);
       const result = applyRemoteOps(ops);
+      for (const [id, crdt] of nodes) {
+        if (crdt.type === CrdtType.TEXT) {
+          const node = context.pool.nodes.get(id);
+          if (node !== void 0 && isLiveText(node)) {
+            const update = node._resyncText(crdt.data, crdt.version);
+            if (update !== void 0) {
+              result.updates.storageUpdates.set(
+                id,
+                mergeStorageUpdates(
+                  result.updates.storageUpdates.get(id),
+                  update
+                )
+              );
+            }
+          }
+        }
+      }
       notify(result.updates);
     } else {
       context.root = LiveObject._fromItems(
@@ -10531,7 +10875,7 @@ function createRoom(options, config) {
         context.pool
       );
     }
-    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _233 => _233.get, 'call', _234 => _234(), 'optionalAccess', _235 => _235.canWrite]), () => ( true));
+    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _234 => _234.get, 'call', _235 => _235(), 'optionalAccess', _236 => _236.canWrite]), () => ( true));
     const root = context.root;
     disableHistory(() => {
       for (const key in context.initialStorage) {
@@ -10738,7 +11082,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _236 => _236.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _237 => _237.addToHistory])) {
         context.activeBatch.reverseOps.pushLeft({
           type: "presence",
           data: oldValues
@@ -10747,7 +11091,7 @@ function createRoom(options, config) {
       context.activeBatch.updates.presence = true;
     } else {
       flushNowOrSoon();
-      if (_optionalChain([options2, 'optionalAccess', _237 => _237.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _238 => _238.addToHistory])) {
         addToUndoStack([{ type: "presence", data: oldValues }]);
       }
       notify({ presence: true });
@@ -10924,11 +11268,11 @@ function createRoom(options, config) {
           break;
         }
         case ServerMsgCode.STORAGE_CHUNK:
-          _optionalChain([stopwatch, 'optionalAccess', _238 => _238.lap, 'call', _239 => _239()]);
+          _optionalChain([stopwatch, 'optionalAccess', _239 => _239.lap, 'call', _240 => _240()]);
           nodeMapBuffer.append(compactNodesToNodeStream(message.nodes));
           break;
         case ServerMsgCode.STORAGE_STREAM_END: {
-          const timing = _optionalChain([stopwatch, 'optionalAccess', _240 => _240.stop, 'call', _241 => _241()]);
+          const timing = _optionalChain([stopwatch, 'optionalAccess', _241 => _241.stop, 'call', _242 => _242()]);
           if (timing) {
             const ms = (v) => `${v.toFixed(1)}ms`;
             const rest = timing.laps.slice(1);
@@ -10955,16 +11299,36 @@ function createRoom(options, config) {
           }
           break;
         }
-        // Receiving a RejectedOps message in the client means that the server is no
-        // longer in sync with the client. Trying to synchronize the client again by
-        // rolling back particular Ops may be hard/impossible. It's fine to not try and
-        // accept the out-of-sync reality and throw an error.
+        // Receiving a RejectedOps message means the server refused some of
+        // our ops, so our optimistic local state is out of sync with the
+        // server. For LiveText ops this is a normal (if rare) situation —
+        // e.g. a client that was offline long enough to fall outside the
+        // server's retained history window — and we can recover: drop the
+        // rejected pending state and re-fetch the authoritative storage
+        // snapshot. For other ops (e.g. permission rejections), rolling back
+        // particular Ops is hard/impossible, so we keep the old behavior of
+        // accepting the out-of-sync reality and surfacing an error.
         case ServerMsgCode.REJECT_STORAGE_OP: {
           errorWithTitle(
             "Storage mutation rejection error",
             message.reason
           );
-          if (process.env.NODE_ENV !== "production") {
+          let needsStorageResync = false;
+          for (const opId of message.opIds) {
+            const rejectedOp = context.unacknowledgedOps.get(opId);
+            context.unacknowledgedOps.delete(opId);
+            context.buffer.storageOperations = context.buffer.storageOperations.filter((op) => op.opId !== opId);
+            if (rejectedOp !== void 0 && rejectedOp.type === OpCode.UPDATE_TEXT) {
+              const node = context.pool.nodes.get(rejectedOp.id);
+              if (node !== void 0 && isLiveText(node)) {
+                node._rejectPendingOp(opId);
+                needsStorageResync = true;
+              }
+            }
+          }
+          if (needsStorageResync) {
+            refreshStorage({ flush: true });
+          } else if (process.env.NODE_ENV !== "production") {
             throw new Error(
               `Storage mutations rejected by server: ${message.reason}`
             );
@@ -11063,11 +11427,11 @@ function createRoom(options, config) {
           } else if (pendingFeedsRequests.has(requestId)) {
             const pending = pendingFeedsRequests.get(requestId);
             pendingFeedsRequests.delete(requestId);
-            _optionalChain([pending, 'optionalAccess', _242 => _242.reject, 'call', _243 => _243(err)]);
+            _optionalChain([pending, 'optionalAccess', _243 => _243.reject, 'call', _244 => _244(err)]);
           } else if (pendingFeedMessagesRequests.has(requestId)) {
             const pending = pendingFeedMessagesRequests.get(requestId);
             pendingFeedMessagesRequests.delete(requestId);
-            _optionalChain([pending, 'optionalAccess', _244 => _244.reject, 'call', _245 => _245(err)]);
+            _optionalChain([pending, 'optionalAccess', _245 => _245.reject, 'call', _246 => _246(err)]);
           }
           eventHub.feeds.notify(message);
           break;
@@ -11221,10 +11585,10 @@ function createRoom(options, config) {
       timeoutId,
       kind,
       feedId,
-      messageId: _optionalChain([options2, 'optionalAccess', _246 => _246.messageId]),
-      expectedClientMessageId: _optionalChain([options2, 'optionalAccess', _247 => _247.expectedClientMessageId])
+      messageId: _optionalChain([options2, 'optionalAccess', _247 => _247.messageId]),
+      expectedClientMessageId: _optionalChain([options2, 'optionalAccess', _248 => _248.expectedClientMessageId])
     });
-    if (kind === "add-message" && _optionalChain([options2, 'optionalAccess', _248 => _248.expectedClientMessageId]) === void 0) {
+    if (kind === "add-message" && _optionalChain([options2, 'optionalAccess', _249 => _249.expectedClientMessageId]) === void 0) {
       const q = _nullishCoalesce(pendingAddMessageFifoByFeed.get(feedId), () => ( []));
       q.push(requestId);
       pendingAddMessageFifoByFeed.set(feedId, q);
@@ -11275,10 +11639,10 @@ function createRoom(options, config) {
           }
           if (!matched) {
             const q = pendingAddMessageFifoByFeed.get(message.feedId);
-            const headId = _optionalChain([q, 'optionalAccess', _249 => _249[0]]);
+            const headId = _optionalChain([q, 'optionalAccess', _250 => _250[0]]);
             if (headId !== void 0) {
               const pending = pendingFeedMutations.get(headId);
-              if (_optionalChain([pending, 'optionalAccess', _250 => _250.kind]) === "add-message" && pending.expectedClientMessageId === void 0) {
+              if (_optionalChain([pending, 'optionalAccess', _251 => _251.kind]) === "add-message" && pending.expectedClientMessageId === void 0) {
                 settleFeedMutation(headId, "ok");
               }
             }
@@ -11314,7 +11678,7 @@ function createRoom(options, config) {
     const unacknowledgedOps2 = [...context.unacknowledgedOps.values()];
     createOrUpdateRootFromMessage(nodes);
     applyAndSendOfflineOps(unacknowledgedOps2);
-    _optionalChain([_resolveStoragePromise, 'optionalCall', _251 => _251()]);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _252 => _252()]);
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
   }
@@ -11332,7 +11696,7 @@ function createRoom(options, config) {
     } else if (!messages.some((msg) => msg.type === ClientMsgCode.FETCH_STORAGE)) {
       messages.push({ type: ClientMsgCode.FETCH_STORAGE });
       nodeMapBuffer.take();
-      _optionalChain([stopwatch, 'optionalAccess', _252 => _252.start, 'call', _253 => _253()]);
+      _optionalChain([stopwatch, 'optionalAccess', _253 => _253.start, 'call', _254 => _254()]);
     }
     if (options2.flush) {
       flushNowOrSoon();
@@ -11388,10 +11752,10 @@ function createRoom(options, config) {
     const message = {
       type: ClientMsgCode.FETCH_FEEDS,
       requestId,
-      cursor: _optionalChain([options2, 'optionalAccess', _254 => _254.cursor]),
-      since: _optionalChain([options2, 'optionalAccess', _255 => _255.since]),
-      limit: _optionalChain([options2, 'optionalAccess', _256 => _256.limit]),
-      metadata: _optionalChain([options2, 'optionalAccess', _257 => _257.metadata])
+      cursor: _optionalChain([options2, 'optionalAccess', _255 => _255.cursor]),
+      since: _optionalChain([options2, 'optionalAccess', _256 => _256.since]),
+      limit: _optionalChain([options2, 'optionalAccess', _257 => _257.limit]),
+      metadata: _optionalChain([options2, 'optionalAccess', _258 => _258.metadata])
     };
     context.buffer.messages.push(message);
     flushNowOrSoon();
@@ -11411,9 +11775,9 @@ function createRoom(options, config) {
       type: ClientMsgCode.FETCH_FEED_MESSAGES,
       requestId,
       feedId,
-      cursor: _optionalChain([options2, 'optionalAccess', _258 => _258.cursor]),
-      since: _optionalChain([options2, 'optionalAccess', _259 => _259.since]),
-      limit: _optionalChain([options2, 'optionalAccess', _260 => _260.limit])
+      cursor: _optionalChain([options2, 'optionalAccess', _259 => _259.cursor]),
+      since: _optionalChain([options2, 'optionalAccess', _260 => _260.since]),
+      limit: _optionalChain([options2, 'optionalAccess', _261 => _261.limit])
     };
     context.buffer.messages.push(message);
     flushNowOrSoon();
@@ -11432,8 +11796,8 @@ function createRoom(options, config) {
       type: ClientMsgCode.ADD_FEED,
       requestId,
       feedId,
-      metadata: _optionalChain([options2, 'optionalAccess', _261 => _261.metadata]),
-      createdAt: _optionalChain([options2, 'optionalAccess', _262 => _262.createdAt])
+      metadata: _optionalChain([options2, 'optionalAccess', _262 => _262.metadata]),
+      createdAt: _optionalChain([options2, 'optionalAccess', _263 => _263.createdAt])
     };
     context.buffer.messages.push(message);
     flushNowOrSoon();
@@ -11467,15 +11831,15 @@ function createRoom(options, config) {
   function addFeedMessage(feedId, data, options2) {
     const requestId = nanoid();
     const promise = registerFeedMutation(requestId, "add-message", feedId, {
-      expectedClientMessageId: _optionalChain([options2, 'optionalAccess', _263 => _263.id])
+      expectedClientMessageId: _optionalChain([options2, 'optionalAccess', _264 => _264.id])
     });
     const message = {
       type: ClientMsgCode.ADD_FEED_MESSAGE,
       requestId,
       feedId,
       data,
-      id: _optionalChain([options2, 'optionalAccess', _264 => _264.id]),
-      createdAt: _optionalChain([options2, 'optionalAccess', _265 => _265.createdAt])
+      id: _optionalChain([options2, 'optionalAccess', _265 => _265.id]),
+      createdAt: _optionalChain([options2, 'optionalAccess', _266 => _266.createdAt])
     };
     context.buffer.messages.push(message);
     flushNowOrSoon();
@@ -11492,7 +11856,7 @@ function createRoom(options, config) {
       feedId,
       messageId,
       data,
-      updatedAt: _optionalChain([options2, 'optionalAccess', _266 => _266.updatedAt])
+      updatedAt: _optionalChain([options2, 'optionalAccess', _267 => _267.updatedAt])
     };
     context.buffer.messages.push(message);
     flushNowOrSoon();
@@ -11699,8 +12063,8 @@ function createRoom(options, config) {
   async function getThreads(options2) {
     return httpClient.getThreads({
       roomId,
-      query: _optionalChain([options2, 'optionalAccess', _267 => _267.query]),
-      cursor: _optionalChain([options2, 'optionalAccess', _268 => _268.cursor])
+      query: _optionalChain([options2, 'optionalAccess', _268 => _268.query]),
+      cursor: _optionalChain([options2, 'optionalAccess', _269 => _269.cursor])
     });
   }
   async function getThread(threadId) {
@@ -11822,7 +12186,7 @@ function createRoom(options, config) {
   function getSubscriptionSettings(options2) {
     return httpClient.getSubscriptionSettings({
       roomId,
-      signal: _optionalChain([options2, 'optionalAccess', _269 => _269.signal])
+      signal: _optionalChain([options2, 'optionalAccess', _270 => _270.signal])
     });
   }
   function updateSubscriptionSettings(settings) {
@@ -11844,7 +12208,7 @@ function createRoom(options, config) {
     {
       [kInternal]: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _270 => _270.buffer, 'access', _271 => _271.presenceUpdates, 'optionalAccess', _272 => _272.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _271 => _271.buffer, 'access', _272 => _272.presenceUpdates, 'optionalAccess', _273 => _273.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -11859,9 +12223,9 @@ function createRoom(options, config) {
           return context.yjsProvider;
         },
         setYjsProvider(newProvider) {
-          _optionalChain([context, 'access', _273 => _273.yjsProvider, 'optionalAccess', _274 => _274.off, 'call', _275 => _275("status", yjsStatusDidChange)]);
+          _optionalChain([context, 'access', _274 => _274.yjsProvider, 'optionalAccess', _275 => _275.off, 'call', _276 => _276("status", yjsStatusDidChange)]);
           context.yjsProvider = newProvider;
-          _optionalChain([newProvider, 'optionalAccess', _276 => _276.on, 'call', _277 => _277("status", yjsStatusDidChange)]);
+          _optionalChain([newProvider, 'optionalAccess', _277 => _277.on, 'call', _278 => _278("status", yjsStatusDidChange)]);
           context.yjsProviderDidChange.notify();
         },
         yjsProviderDidChange: context.yjsProviderDidChange.observable,
@@ -11919,7 +12283,7 @@ ${dumpPool(context.pool)}`;
           source.dispose();
         }
         eventHub.roomWillDestroy.notify();
-        _optionalChain([context, 'access', _278 => _278.yjsProvider, 'optionalAccess', _279 => _279.off, 'call', _280 => _280("status", yjsStatusDidChange)]);
+        _optionalChain([context, 'access', _279 => _279.yjsProvider, 'optionalAccess', _280 => _280.off, 'call', _281 => _281("status", yjsStatusDidChange)]);
         syncSourceForStorage.destroy();
         syncSourceForYjs.destroy();
         uninstallBgTabSpy();
@@ -12079,7 +12443,7 @@ function makeClassicSubscribeFn(roomId, events, errorEvents) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _281 => _281.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _282 => _282.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -12165,8 +12529,8 @@ function createClient(options) {
   const authManager = createAuthManager(options, (token) => {
     currentUserId.set(() => token.uid);
   });
-  const fetchPolyfill = _optionalChain([clientOptions, 'access', _282 => _282.polyfills, 'optionalAccess', _283 => _283.fetch]) || /* istanbul ignore next */
-  _optionalChain([globalThis, 'access', _284 => _284.fetch, 'optionalAccess', _285 => _285.bind, 'call', _286 => _286(globalThis)]);
+  const fetchPolyfill = _optionalChain([clientOptions, 'access', _283 => _283.polyfills, 'optionalAccess', _284 => _284.fetch]) || /* istanbul ignore next */
+  _optionalChain([globalThis, 'access', _285 => _285.fetch, 'optionalAccess', _286 => _286.bind, 'call', _287 => _287(globalThis)]);
   const httpClient = createApiClient({
     baseUrl,
     fetchPolyfill,
@@ -12184,7 +12548,7 @@ function createClient(options) {
     delegates: {
       createSocket: makeCreateSocketDelegateForAi(
         baseUrl,
-        _optionalChain([clientOptions, 'access', _287 => _287.polyfills, 'optionalAccess', _288 => _288.WebSocket])
+        _optionalChain([clientOptions, 'access', _288 => _288.polyfills, 'optionalAccess', _289 => _289.WebSocket])
       ),
       authenticate: async () => {
         const resp = await authManager.getAuthValue({
@@ -12254,7 +12618,7 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             baseUrl,
-            _optionalChain([clientOptions, 'access', _289 => _289.polyfills, 'optionalAccess', _290 => _290.WebSocket])
+            _optionalChain([clientOptions, 'access', _290 => _290.polyfills, 'optionalAccess', _291 => _291.WebSocket])
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         })),
@@ -12277,7 +12641,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.autoConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _291 => _291.polyfills, 'optionalAccess', _292 => _292.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _292 => _292.polyfills, 'optionalAccess', _293 => _293.atob]) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
@@ -12289,7 +12653,7 @@ function createClient(options) {
     return leaseRoom(newRoomDetails);
   }
   function getRoom(roomId) {
-    const room = _optionalChain([roomsById, 'access', _293 => _293.get, 'call', _294 => _294(roomId), 'optionalAccess', _295 => _295.room]);
+    const room = _optionalChain([roomsById, 'access', _294 => _294.get, 'call', _295 => _295(roomId), 'optionalAccess', _296 => _296.room]);
     return room ? room : null;
   }
   function logout() {
@@ -12305,7 +12669,7 @@ function createClient(options) {
   const batchedResolveUsers = new Batch(
     async (batchedUserIds) => {
       const userIds = batchedUserIds.flat();
-      const users = await _optionalChain([resolveUsers, 'optionalCall', _296 => _296({ userIds })]);
+      const users = await _optionalChain([resolveUsers, 'optionalCall', _297 => _297({ userIds })]);
       warnOnceIf(
         !resolveUsers,
         "Set the resolveUsers option in createClient to specify user info."
@@ -12322,7 +12686,7 @@ function createClient(options) {
   const batchedResolveRoomsInfo = new Batch(
     async (batchedRoomIds) => {
       const roomIds = batchedRoomIds.flat();
-      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _297 => _297({ roomIds })]);
+      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _298 => _298({ roomIds })]);
       warnOnceIf(
         !resolveRoomsInfo,
         "Set the resolveRoomsInfo option in createClient to specify room info."
@@ -12339,7 +12703,7 @@ function createClient(options) {
   const batchedResolveGroupsInfo = new Batch(
     async (batchedGroupIds) => {
       const groupIds = batchedGroupIds.flat();
-      const groupsInfo = await _optionalChain([resolveGroupsInfo, 'optionalCall', _298 => _298({ groupIds })]);
+      const groupsInfo = await _optionalChain([resolveGroupsInfo, 'optionalCall', _299 => _299({ groupIds })]);
       warnOnceIf(
         !resolveGroupsInfo,
         "Set the resolveGroupsInfo option in createClient to specify group info."
@@ -12398,7 +12762,7 @@ function createClient(options) {
       }
     };
     const win = typeof window !== "undefined" ? window : void 0;
-    _optionalChain([win, 'optionalAccess', _299 => _299.addEventListener, 'call', _300 => _300("beforeunload", maybePreventClose)]);
+    _optionalChain([win, 'optionalAccess', _300 => _300.addEventListener, 'call', _301 => _301("beforeunload", maybePreventClose)]);
   }
   async function getNotificationSettings(options2) {
     const plainSettings = await httpClient.getNotificationSettings(options2);
@@ -12526,7 +12890,7 @@ var commentBodyElementsTypes = {
   mention: "inline"
 };
 function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
-  if (!body || !_optionalChain([body, 'optionalAccess', _301 => _301.content])) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _302 => _302.content])) {
     return;
   }
   const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
@@ -12536,13 +12900,13 @@ function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
   for (const block of body.content) {
     if (type === "all" || type === "block") {
       if (guard(block)) {
-        _optionalChain([visitor, 'optionalCall', _302 => _302(block)]);
+        _optionalChain([visitor, 'optionalCall', _303 => _303(block)]);
       }
     }
     if (type === "all" || type === "inline") {
       for (const inline of block.children) {
         if (guard(inline)) {
-          _optionalChain([visitor, 'optionalCall', _303 => _303(inline)]);
+          _optionalChain([visitor, 'optionalCall', _304 => _304(inline)]);
         }
       }
     }
@@ -12712,7 +13076,7 @@ var stringifyCommentBodyPlainElements = {
   text: ({ element }) => element.text,
   link: ({ element }) => _nullishCoalesce(element.text, () => ( element.url)),
   mention: ({ element, user, group }) => {
-    return `@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _304 => _304.name]), () => ( _optionalChain([group, 'optionalAccess', _305 => _305.name]))), () => ( element.id))}`;
+    return `@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _305 => _305.name]), () => ( _optionalChain([group, 'optionalAccess', _306 => _306.name]))), () => ( element.id))}`;
   }
 };
 var stringifyCommentBodyHtmlElements = {
@@ -12742,7 +13106,7 @@ var stringifyCommentBodyHtmlElements = {
     return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.text ? html`${element.text}` : element.url}</a>`;
   },
   mention: ({ element, user, group }) => {
-    return html`<span data-mention>@${_optionalChain([user, 'optionalAccess', _306 => _306.name]) ? html`${_optionalChain([user, 'optionalAccess', _307 => _307.name])}` : _optionalChain([group, 'optionalAccess', _308 => _308.name]) ? html`${_optionalChain([group, 'optionalAccess', _309 => _309.name])}` : element.id}</span>`;
+    return html`<span data-mention>@${_optionalChain([user, 'optionalAccess', _307 => _307.name]) ? html`${_optionalChain([user, 'optionalAccess', _308 => _308.name])}` : _optionalChain([group, 'optionalAccess', _309 => _309.name]) ? html`${_optionalChain([group, 'optionalAccess', _310 => _310.name])}` : element.id}</span>`;
   }
 };
 var stringifyCommentBodyMarkdownElements = {
@@ -12772,20 +13136,20 @@ var stringifyCommentBodyMarkdownElements = {
     return markdown`[${_nullishCoalesce(element.text, () => ( element.url))}](${href})`;
   },
   mention: ({ element, user, group }) => {
-    return markdown`@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _310 => _310.name]), () => ( _optionalChain([group, 'optionalAccess', _311 => _311.name]))), () => ( element.id))}`;
+    return markdown`@${_nullishCoalesce(_nullishCoalesce(_optionalChain([user, 'optionalAccess', _311 => _311.name]), () => ( _optionalChain([group, 'optionalAccess', _312 => _312.name]))), () => ( element.id))}`;
   }
 };
 async function stringifyCommentBody(body, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _312 => _312.format]), () => ( "plain"));
-  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _313 => _313.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _313 => _313.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _314 => _314.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
   const elements = {
     ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ..._optionalChain([options, 'optionalAccess', _314 => _314.elements])
+    ..._optionalChain([options, 'optionalAccess', _315 => _315.elements])
   };
   const { users: resolvedUsers, groups: resolvedGroupsInfo } = await resolveMentionsInCommentBody(
     body,
-    _optionalChain([options, 'optionalAccess', _315 => _315.resolveUsers]),
-    _optionalChain([options, 'optionalAccess', _316 => _316.resolveGroupsInfo])
+    _optionalChain([options, 'optionalAccess', _316 => _316.resolveUsers]),
+    _optionalChain([options, 'optionalAccess', _317 => _317.resolveGroupsInfo])
   );
   const blocks = body.content.flatMap((block, blockIndex) => {
     switch (block.type) {
@@ -12926,9 +13290,9 @@ function makePoller(callback, intervalMs, options) {
   const startTime = performance.now();
   const doc = typeof document !== "undefined" ? document : void 0;
   const win = typeof window !== "undefined" ? window : void 0;
-  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _317 => _317.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
+  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _318 => _318.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
   const context = {
-    inForeground: _optionalChain([doc, 'optionalAccess', _318 => _318.visibilityState]) !== "hidden",
+    inForeground: _optionalChain([doc, 'optionalAccess', _319 => _319.visibilityState]) !== "hidden",
     lastSuccessfulPollAt: startTime,
     count: 0,
     backoff: 0
@@ -13009,11 +13373,11 @@ function makePoller(callback, intervalMs, options) {
     pollNowIfStale();
   }
   function onVisibilityChange() {
-    setInForeground(_optionalChain([doc, 'optionalAccess', _319 => _319.visibilityState]) !== "hidden");
+    setInForeground(_optionalChain([doc, 'optionalAccess', _320 => _320.visibilityState]) !== "hidden");
   }
-  _optionalChain([doc, 'optionalAccess', _320 => _320.addEventListener, 'call', _321 => _321("visibilitychange", onVisibilityChange)]);
-  _optionalChain([win, 'optionalAccess', _322 => _322.addEventListener, 'call', _323 => _323("online", onVisibilityChange)]);
-  _optionalChain([win, 'optionalAccess', _324 => _324.addEventListener, 'call', _325 => _325("focus", pollNowIfStale)]);
+  _optionalChain([doc, 'optionalAccess', _321 => _321.addEventListener, 'call', _322 => _322("visibilitychange", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _323 => _323.addEventListener, 'call', _324 => _324("online", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _325 => _325.addEventListener, 'call', _326 => _326("focus", pollNowIfStale)]);
   fsm.start();
   return {
     inc,