@liveblocks/core 3.20.0 → 3.21.0-exp10

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.20.0";
+var PKG_VERSION = "3.21.0-exp10";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -3847,6 +3847,7 @@ var ManagedSocket = class {
 
 // src/internal.ts
 var kInternal = /* @__PURE__ */ Symbol();
+var kStorageUpdateSource = /* @__PURE__ */ Symbol();
 
 // src/lib/IncrementalJsonParser.ts
 var EMPTY_OBJECT = Object.freeze({});
@@ -5767,13 +5768,15 @@ var OpCode = Object.freeze({
   DELETE_CRDT: 5,
   DELETE_OBJECT_KEY: 6,
   CREATE_MAP: 7,
-  CREATE_REGISTER: 8
+  CREATE_REGISTER: 8,
+  CREATE_TEXT: 9,
+  UPDATE_TEXT: 10
 });
 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
@@ -5781,7 +5784,8 @@ var CrdtType = Object.freeze({
   OBJECT: 0,
   LIST: 1,
   MAP: 2,
-  REGISTER: 3
+  REGISTER: 3,
+  TEXT: 4
 });
 function isRootStorageNode(node) {
   return node[0] === "root";
@@ -5798,6 +5802,9 @@ function isMapStorageNode(node) {
 function isRegisterStorageNode(node) {
   return node[1].type === CrdtType.REGISTER;
 }
+function isTextStorageNode(node) {
+  return node[1].type === CrdtType.TEXT;
+}
 function isCompactRootNode(node) {
   return node[0] === "root";
 }
@@ -5820,6 +5827,9 @@ function* compactNodesToNodeStream(compactNodes) {
       case CrdtType.REGISTER:
         yield [cnode[0], { type: CrdtType.REGISTER, parentId: cnode[2], parentKey: cnode[3], data: cnode[4] }];
         break;
+      case CrdtType.TEXT:
+        yield [cnode[0], { type: CrdtType.TEXT, parentId: cnode[2], parentKey: cnode[3], data: cnode[4], version: cnode[5] }];
+        break;
       default:
     }
   }
@@ -5848,6 +5858,17 @@ function* nodeStreamToCompactNodes(nodes) {
       const id = node[0];
       const crdt = node[1];
       yield [id, CrdtType.REGISTER, crdt.parentId, crdt.parentKey, crdt.data];
+    } else if (isTextStorageNode(node)) {
+      const id = node[0];
+      const crdt = node[1];
+      yield [
+        id,
+        CrdtType.TEXT,
+        crdt.parentId,
+        crdt.parentKey,
+        crdt.data,
+        crdt.version
+      ];
     } else {
     }
   }
@@ -6050,6 +6071,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.
    */
@@ -6150,8 +6175,8 @@ function createManagedPool(roomId, options) {
     deleteNode: (id) => void nodes.delete(id),
     generateId: () => `${getCurrentConnectionId()}:${clock++}`,
     generateOpId: () => `${getCurrentConnectionId()}:${opClock++}`,
-    dispatch(ops, reverse, storageUpdates) {
-      onDispatch?.(ops, reverse, storageUpdates);
+    dispatch(ops, reverse, storageUpdates, options2) {
+      onDispatch?.(ops, reverse, storageUpdates, options2);
     },
     assertStorageIsWritable: () => {
       if (!isStorageWritable()) {
@@ -8710,6 +8735,1117 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   }
 };
 
+// src/crdts/liveTextOps.ts
+function attributesEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (left === void 0 || right === void 0) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (const key of leftKeys) {
+    if (left[key] !== right[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function cloneAttributes(attributes) {
+  return attributes === void 0 ? void 0 : freeze({ ...attributes });
+}
+function normalizeSegments(segments) {
+  const normalized = [];
+  for (const segment of segments) {
+    if (segment.text.length === 0) {
+      continue;
+    }
+    const last = normalized.at(-1);
+    const attributes = cloneAttributes(segment.attributes);
+    if (last !== void 0 && attributesEqual(last.attributes, attributes)) {
+      last.text += segment.text;
+    } else {
+      normalized.push({ text: segment.text, attributes });
+    }
+  }
+  return normalized;
+}
+function dataToSegments(data) {
+  return normalizeSegments(
+    data.map(([text, attributes]) => ({
+      text,
+      attributes
+    }))
+  );
+}
+function segmentsToData(segments) {
+  return segments.map(
+    (segment) => segment.attributes === void 0 ? [segment.text] : [segment.text, { ...segment.attributes }]
+  );
+}
+function textLength(segments) {
+  return segments.reduce((sum, segment) => sum + segment.text.length, 0);
+}
+function splitSegmentsAt(segments, index) {
+  const result = [];
+  let offset = 0;
+  for (const segment of segments) {
+    const end = offset + segment.text.length;
+    if (index > offset && index < end) {
+      const before2 = segment.text.slice(0, index - offset);
+      const after2 = segment.text.slice(index - offset);
+      result.push({ text: before2, attributes: segment.attributes });
+      result.push({ text: after2, attributes: segment.attributes });
+    } else {
+      result.push({ text: segment.text, attributes: segment.attributes });
+    }
+    offset = end;
+  }
+  return result;
+}
+function clipRange(index, length, contentLength) {
+  const clippedIndex = Math.max(0, Math.min(index, contentLength));
+  const clippedEnd = Math.max(
+    clippedIndex,
+    Math.min(index + length, contentLength)
+  );
+  return { index: clippedIndex, length: clippedEnd - clippedIndex };
+}
+function applyInsert(segments, index, text, attributes) {
+  if (text.length === 0) {
+    return normalizeSegments(segments);
+  }
+  const split = splitSegmentsAt(segments, index);
+  const result = [];
+  let offset = 0;
+  let inserted = false;
+  for (const segment of split) {
+    if (!inserted && offset === index) {
+      result.push({ text, attributes });
+      inserted = true;
+    }
+    result.push(segment);
+    offset += segment.text.length;
+  }
+  if (!inserted) {
+    result.push({ text, attributes });
+  }
+  return normalizeSegments(result);
+}
+function extractDeletedSegments(segments, index, length) {
+  const split = splitSegmentsAt(
+    splitSegmentsAt(segments, index),
+    index + length
+  );
+  const deleted = [];
+  let offset = 0;
+  for (const segment of split) {
+    const end = offset + segment.text.length;
+    if (offset >= index && end <= index + length) {
+      deleted.push({
+        text: segment.text,
+        attributes: segment.attributes
+      });
+    }
+    offset = end;
+  }
+  return normalizeSegments(deleted);
+}
+function applyDelete(segments, index, length) {
+  const deletedSegments = extractDeletedSegments(segments, index, length);
+  const split = splitSegmentsAt(
+    splitSegmentsAt(segments, index),
+    index + length
+  );
+  const result = [];
+  let offset = 0;
+  let deletedText = "";
+  for (const segment of split) {
+    const end = offset + segment.text.length;
+    if (offset >= index && end <= index + length) {
+      deletedText += segment.text;
+    } else {
+      result.push(segment);
+    }
+    offset = end;
+  }
+  return {
+    segments: normalizeSegments(result),
+    deletedText,
+    deletedSegments
+  };
+}
+function applyFormat(segments, index, length, attributes) {
+  const split = splitSegmentsAt(
+    splitSegmentsAt(segments, index),
+    index + length
+  );
+  const result = [];
+  let offset = 0;
+  for (const segment of split) {
+    const end = offset + segment.text.length;
+    if (offset >= index && end <= index + length) {
+      const nextAttributes = {
+        ...segment.attributes ?? {}
+      };
+      for (const [key, value] of Object.entries(attributes)) {
+        if (value === null) {
+          delete nextAttributes[key];
+        } else {
+          nextAttributes[key] = value;
+        }
+      }
+      result.push({
+        text: segment.text,
+        attributes: Object.keys(nextAttributes).length === 0 ? void 0 : freeze(nextAttributes)
+      });
+    } else {
+      result.push(segment);
+    }
+    offset = end;
+  }
+  return normalizeSegments(result);
+}
+function formatReverseOperations(segments, index, length, patch) {
+  const split = splitSegmentsAt(
+    splitSegmentsAt(segments, index),
+    index + length
+  );
+  const result = [];
+  let offset = 0;
+  for (const segment of split) {
+    const end = offset + segment.text.length;
+    if (offset >= index && end <= index + length) {
+      const attributes = {};
+      for (const key of Object.keys(patch)) {
+        attributes[key] = segment.attributes?.[key] ?? null;
+      }
+      result.push({
+        type: "format",
+        index: offset,
+        length: segment.text.length,
+        attributes
+      });
+    }
+    offset = end;
+  }
+  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 {
+    return index;
+  }
+}
+function mapTextIndexThroughOperations(index, ops) {
+  let mapped = index;
+  for (const op of ops) {
+    mapped = mapIndexThroughOperation(mapped, op);
+  }
+  return mapped;
+}
+function inverseMapIndexThroughOperation(index, op) {
+  if (op.type === "insert") {
+    if (index <= op.index) {
+      return index;
+    }
+    return Math.max(op.index, index - op.text.length);
+  } else if (op.type === "delete") {
+    return op.index <= index ? index + op.length : index;
+  } else {
+    return index;
+  }
+}
+function inverseMapTextIndexThroughOperations(index, ops) {
+  let mapped = index;
+  for (let i = ops.length - 1; i >= 0; i--) {
+    mapped = inverseMapIndexThroughOperation(mapped, ops[i]);
+  }
+  return mapped;
+}
+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 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 }];
+  }
+}
+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];
+  for (const op of ops) {
+    if (op.type === "insert") {
+      const index = Math.max(0, Math.min(op.index, textLength(next)));
+      next = applyInsert(next, index, op.text, op.attributes);
+    } else if (op.type === "delete") {
+      const index = Math.max(0, Math.min(op.index, textLength(next)));
+      const clipped = clipRange(index, op.length, textLength(next));
+      next = applyDelete(next, clipped.index, clipped.length).segments;
+    } else {
+      const index = Math.max(0, Math.min(op.index, textLength(next)));
+      const clipped = clipRange(index, op.length, textLength(next));
+      next = applyFormat(next, clipped.index, clipped.length, op.attributes);
+    }
+  }
+  return next;
+}
+function applyLiveTextOperations(data, ops) {
+  return segmentsToData(
+    applyTextOperationsToSegments(dataToSegments(data), ops)
+  );
+}
+function invertTextOperations(segments, ops) {
+  let shadow = [...segments];
+  const reverse = [];
+  for (const op of ops) {
+    if (op.type === "insert") {
+      shadow = applyInsert(shadow, op.index, op.text, op.attributes);
+      reverse.unshift({
+        type: "delete",
+        index: op.index,
+        length: op.text.length
+      });
+    } else if (op.type === "delete") {
+      const deletedSegments = extractDeletedSegments(
+        shadow,
+        op.index,
+        op.length
+      );
+      shadow = applyDelete(shadow, op.index, op.length).segments;
+      const inserts = [];
+      let insertIndex = op.index;
+      for (const segment of deletedSegments) {
+        inserts.push({
+          type: "insert",
+          index: insertIndex,
+          text: segment.text,
+          attributes: segment.attributes
+        });
+        insertIndex += segment.text.length;
+      }
+      for (let index = inserts.length - 1; index >= 0; index--) {
+        reverse.unshift(inserts[index]);
+      }
+    } else {
+      const inverse = formatReverseOperations(
+        shadow,
+        op.index,
+        op.length,
+        op.attributes
+      );
+      shadow = applyFormat(shadow, op.index, op.length, op.attributes);
+      reverse.unshift(...inverse.reverse());
+    }
+  }
+  return reverse;
+}
+
+// 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;
+  /** 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 = [];
+  /**
+   * Creates a new LiveText document.
+   *
+   * @param textOrData Initial plain text, or an array of `[text]` /
+   *   `[text, attributes]` segments. Defaults to an empty document.
+   *
+   * @example
+   * new LiveText();
+   * new LiveText("Hello world");
+   * new LiveText([["Hello ", { bold: true }], ["world"]]);
+   */
+  constructor(textOrData = "", version = 0) {
+    super();
+    this.#segments = typeof textOrData === "string" ? textOrData.length === 0 ? [] : [{ text: textOrData }] : dataToSegments(textOrData);
+    this.#confirmed = [...this.#segments];
+    this.#version = version;
+    Object.defineProperty(this, kInternal, {
+      value: {
+        encodeIndex: (localIndex) => this.#encodeIndex(localIndex),
+        decodeIndex: (index, fromVersion) => this.#decodeIndex(index, fromVersion)
+      },
+      enumerable: false
+    });
+  }
+  get version() {
+    return this.#version;
+  }
+  get length() {
+    return textLength(this.#segments);
+  }
+  /** @internal */
+  static _deserialize([id, item], _parentToChildren, pool) {
+    const text = new _LiveText(item.data, item.version);
+    text._attach(id, pool);
+    return text;
+  }
+  /** @internal */
+  _toOps(parentId, parentKey) {
+    if (this._id === void 0) {
+      throw new Error("Cannot serialize LiveText if it is not attached");
+    }
+    return [
+      {
+        type: OpCode.CREATE_TEXT,
+        id: this._id,
+        parentId,
+        parentKey,
+        data: this.toJSON(),
+        version: this.#version
+      }
+    ];
+  }
+  /** @internal */
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveText if parent is missing");
+    }
+    return {
+      type: CrdtType.TEXT,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key,
+      data: this.toJSON(),
+      version: this.#version
+    };
+  }
+  /** @internal */
+  _attachChild(_op) {
+    throw new Error("LiveText cannot contain child nodes");
+  }
+  /** @internal */
+  _detachChild(_crdt) {
+    throw new Error("LiveText cannot contain child nodes");
+  }
+  /** @internal */
+  _apply(op, isLocal) {
+    if (op.type !== OpCode.UPDATE_TEXT) {
+      return super._apply(op, isLocal);
+    }
+    if (isLocal) {
+      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, op.version ?? op.baseVersion + 1);
+      return { modified: false };
+    }
+    return this.#applyRemote(op);
+  }
+  /**
+   * Inserts text at the given index.
+   *
+   * @param index Character index at which to insert. Values outside the
+   *   document range are clipped.
+   * @param text Text to insert.
+   * @param attributes Optional inline attributes for the inserted text.
+   *
+   * @example
+   * const text = new LiveText("Hello");
+   * text.insert(5, " world");
+   * text.insert(0, "Say: ", { italic: true });
+   */
+  insert(index, text, attributes) {
+    const clippedIndex = Math.max(0, Math.min(index, this.length));
+    this.#dispatch([{ type: "insert", index: clippedIndex, text, attributes }]);
+  }
+  /**
+   * Deletes `length` characters starting at `index`.
+   *
+   * @example
+   * const text = new LiveText("Hello world");
+   * text.delete(5, 6); // "Hello"
+   */
+  delete(index, length) {
+    const clipped = clipRange(index, length, this.length);
+    if (clipped.length === 0) {
+      return;
+    }
+    this.#dispatch([
+      { type: "delete", index: clipped.index, length: clipped.length }
+    ]);
+  }
+  /**
+   * Replaces a range of text with new text.
+   *
+   * @example
+   * const text = new LiveText("Hello world");
+   * text.replace(0, 5, "Hi"); // "Hi world"
+   */
+  replace(index, length, text, attributes) {
+    const clipped = clipRange(index, length, this.length);
+    const ops = [];
+    if (clipped.length > 0) {
+      ops.push({
+        type: "delete",
+        index: clipped.index,
+        length: clipped.length
+      });
+    }
+    if (text.length > 0) {
+      ops.push({ type: "insert", index: clipped.index, text, attributes });
+    }
+    this.#dispatch(ops);
+  }
+  /**
+   * Encode a local-document index (an offset into this LiveText's current
+   * #segments, which CodeMirror or any consumer mirrors as its document)
+   * into server-confirmed coordinates suitable for broadcasting to peers via
+   * presence or any other side channel.
+   *
+   * The returned index is in this LiveText's current #confirmed coordinates
+   * — that is, with this client's local pending ops inverse-mapped out.
+   * Pair it with the current {@link LiveText.version} when sending so the
+   * receiver can call {@link PrivateLiveTextApi.decodeIndex} to land the
+   * position in their own local document coordinates regardless of their
+   * private pending ops.
+   *
+   * Index ambiguity at boundaries is resolved by an inverse-of-forward
+   * convention: a position at or before a local insertion is reported as
+   * the position right before the insertion in #confirmed; a position past
+   * the insertion shifts left by the insertion's length. Positions inside
+   * an own-pending insertion collapse to the insertion point.
+   */
+  #encodeIndex(localIndex) {
+    let mapped = Math.max(0, Math.min(localIndex, this.length));
+    mapped = inverseMapTextIndexThroughOperations(mapped, this.#queuedOps);
+    mapped = inverseMapTextIndexThroughOperations(mapped, this.#inFlightOps);
+    return mapped;
+  }
+  /**
+   * Decode an `(index, fromVersion)` pair produced by
+   * {@link PrivateLiveTextApi.encodeIndex} — typically on a peer — into an
+   * offset in this LiveText's current local document (an index suitable for
+   * placing a CodeMirror marker, an annotation anchor, or anything else that
+   * lives over #segments).
+   *
+   * Composes the accepted ops applied since `fromVersion` (drawn from
+   * #acceptedOps in locally-applied form) with this client's own local
+   * pending ops, in that order. The result is in current #segments
+   * coordinates.
+   *
+   * Returns `null` when the position cannot be decoded against the current
+   * state:
+   *  - `fromVersion` is greater than this LiveText's current version: the
+   *    peer is ahead of us. The caller should park the message and retry
+   *    after more accepted ops arrive.
+   *  - `fromVersion` falls outside the retained accepted-ops history. This
+   *    only happens after very long-lived disconnections; the caller can
+   *    fall back to using the raw index and letting subsequent local
+   *    transactions map it (with bounded drift).
+   */
+  #decodeIndex(index, fromVersion) {
+    if (fromVersion > this.#version) {
+      return null;
+    }
+    if (fromVersion < this.#version) {
+      const oldest = this.#acceptedOps[0]?.version;
+      if (oldest === void 0 || oldest > fromVersion + 1) {
+        return null;
+      }
+    }
+    let mapped = index;
+    for (const entry of this.#acceptedOps) {
+      if (entry.version <= fromVersion) continue;
+      if (entry.version > this.#version) break;
+      if (entry.ops.length === 0) continue;
+      mapped = mapTextIndexThroughOperations(mapped, entry.ops);
+    }
+    mapped = mapTextIndexThroughOperations(mapped, this.#inFlightOps);
+    mapped = mapTextIndexThroughOperations(mapped, this.#queuedOps);
+    return Math.max(0, Math.min(mapped, this.length));
+  }
+  /**
+   * Applies or removes inline attributes on a range of text.
+   *
+   * Set an attribute to `null` to remove it from the range.
+   *
+   * @example
+   * const text = new LiveText("Hello world");
+   * text.format(0, 5, { bold: true });
+   * text.format(0, 5, { bold: null });
+   */
+  format(index, length, attributes) {
+    const clipped = clipRange(index, length, this.length);
+    if (clipped.length === 0) {
+      return;
+    }
+    this.#dispatch([
+      {
+        type: "format",
+        index: clipped.index,
+        length: clipped.length,
+        attributes
+      }
+    ]);
+  }
+  /** Local edits made through the public API. */
+  #dispatch(ops) {
+    if (ops.length === 0) {
+      return;
+    }
+    this._pool?.assertStorageIsWritable();
+    const attached = this._pool !== void 0 && this._id !== void 0;
+    const reverse = attached ? this.#invertOperations(ops) : [];
+    const changes = this.#applyOperationsLocally(ops);
+    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,
+            opId,
+            baseVersion: this.#version,
+            ops: [...ops]
+          }
+        ],
+        reverse,
+        updates
+      );
+    } else {
+      this.#queuedOps.push(...ops);
+      pool.dispatch([], reverse, updates, { clearRedoStack: true });
+    }
+  }
+  /**
+   * 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 = 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 = 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,
+      modified: {
+        type: "LiveText",
+        node: this,
+        version: this.#version,
+        updates: changes
+      }
+    };
+  }
+  /** 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) {
+      if (op.type === "insert") {
+        this.#segments = applyInsert(
+          this.#segments,
+          op.index,
+          op.text,
+          op.attributes
+        );
+        changes.push({
+          type: "insert",
+          index: op.index,
+          text: op.text,
+          attributes: op.attributes
+        });
+      } else if (op.type === "delete") {
+        const result = applyDelete(this.#segments, op.index, op.length);
+        this.#segments = result.segments;
+        changes.push({
+          type: "delete",
+          index: op.index,
+          length: op.length,
+          deletedText: result.deletedText
+        });
+      } else {
+        this.#segments = applyFormat(
+          this.#segments,
+          op.index,
+          op.length,
+          op.attributes
+        );
+        changes.push({
+          type: "format",
+          index: op.index,
+          length: op.length,
+          attributes: op.attributes
+        });
+      }
+    }
+    this.invalidate();
+    return changes;
+  }
+  #invertOperations(ops) {
+    return [
+      {
+        type: OpCode.UPDATE_TEXT,
+        id: nn(this._id),
+        baseVersion: this.#version,
+        ops: invertTextOperations(this.#segments, ops)
+      }
+    ];
+  }
+  /** Returns the plain text content without attributes. Equivalent to joining the text from each segment in {@link LiveText.toJSON}. */
+  toString() {
+    return this.#segments.map((segment) => segment.text).join("");
+  }
+  /**
+   * Returns a JSON-compatible snapshot of the document as a {@link LiveTextData}
+   * array.
+   *
+   * @example
+   * new LiveText([["Hello ", { bold: true }], ["world"]]).toJSON();
+   * // [["Hello ", { bold: true }], ["world"]]
+   */
+  toJSON() {
+    return super.toJSON();
+  }
+  /** @internal */
+  _toJSON() {
+    return segmentsToData(this.#segments);
+  }
+  /** @internal */
+  toTreeNode(key) {
+    return super.toTreeNode(key);
+  }
+  /** @internal */
+  _toTreeNode(key) {
+    const nodeId = this._id ?? nanoid();
+    const payload = this.toJSON().map(
+      (segment, index) => ({
+        type: "Json",
+        id: `${nodeId}:${index}`,
+        key: String(index),
+        payload: segment
+      })
+    );
+    payload.push({
+      type: "Json",
+      id: `${nodeId}:version`,
+      key: "version",
+      payload: this.version
+    });
+    return {
+      type: "LiveText",
+      id: nodeId,
+      key,
+      payload
+    };
+  }
+  clone() {
+    return new _LiveText(this.toJSON(), this.#version);
+  }
+};
+
 // src/crdts/liveblocks-helpers.ts
 function creationOpToLiveNode(op) {
   return lsonToLiveNode(creationOpToLson(op));
@@ -8724,6 +9860,8 @@ function creationOpToLson(op) {
       return new LiveMap();
     case OpCode.CREATE_LIST:
       return new LiveList([]);
+    case OpCode.CREATE_TEXT:
+      return new LiveText(op.data, op.version);
     default:
       return assertNever(op, "Unknown creation Op");
   }
@@ -8746,6 +9884,8 @@ function deserialize(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return LiveRegister._deserialize(node, parentToChildren, pool);
+  } else if (isTextStorageNode(node)) {
+    return LiveText._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
@@ -8759,12 +9899,14 @@ function deserializeToLson(node, parentToChildren, pool) {
     return LiveMap._deserialize(node, parentToChildren, pool);
   } else if (isRegisterStorageNode(node)) {
     return node[1].data;
+  } else if (isTextStorageNode(node)) {
+    return LiveText._deserialize(node, parentToChildren, pool);
   } else {
     throw new Error("Unexpected CRDT type");
   }
 }
 function isLiveStructure(value) {
-  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
+  return isLiveList(value) || isLiveMap(value) || isLiveObject(value) || isLiveText(value);
 }
 function isLiveNode(value) {
   return isLiveStructure(value) || isLiveRegister(value);
@@ -8778,6 +9920,9 @@ function isLiveMap(value) {
 function isLiveObject(value) {
   return value instanceof LiveObject;
 }
+function isLiveText(value) {
+  return value instanceof LiveText;
+}
 function isLiveRegister(value) {
   return value instanceof LiveRegister;
 }
@@ -8787,14 +9932,14 @@ function cloneLson(value) {
 function liveNodeToLson(obj) {
   if (obj instanceof LiveRegister) {
     return obj.data;
-  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
+  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject || obj instanceof LiveText) {
     return obj;
   } else {
     return assertNever(obj, "Unknown AbstractCrdt");
   }
 }
 function lsonToLiveNode(value) {
-  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
+  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList || value instanceof LiveText) {
     return value;
   } else {
     return new LiveRegister(value);
@@ -8937,6 +10082,16 @@ function diffNodeMap(prev, next) {
             parentKey: crdt.parentKey
           });
           break;
+        case CrdtType.TEXT:
+          ops.push({
+            type: OpCode.CREATE_TEXT,
+            id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey,
+            data: crdt.data,
+            version: crdt.version
+          });
+          break;
       }
     }
   });
@@ -8969,19 +10124,43 @@ function mergeListStorageUpdates(first, second) {
     updates: updates.concat(second.updates)
   };
 }
+function mergeTextStorageUpdates(first, second) {
+  return {
+    ...second,
+    updates: first.updates.concat(second.updates)
+  };
+}
 function mergeStorageUpdates(first, second) {
   if (first === void 0) {
     return second;
   }
+  let merged;
   if (first.type === "LiveObject" && second.type === "LiveObject") {
-    return mergeObjectStorageUpdates(first, second);
+    merged = mergeObjectStorageUpdates(first, second);
   } else if (first.type === "LiveMap" && second.type === "LiveMap") {
-    return mergeMapStorageUpdates(first, second);
+    merged = mergeMapStorageUpdates(first, second);
   } else if (first.type === "LiveList" && second.type === "LiveList") {
-    return mergeListStorageUpdates(first, second);
+    merged = mergeListStorageUpdates(first, second);
+  } else if (first.type === "LiveText" && second.type === "LiveText") {
+    merged = mergeTextStorageUpdates(first, second);
   } else {
+    merged = second;
+  }
+  const sa = first[kStorageUpdateSource];
+  const sb = second[kStorageUpdateSource];
+  if (sa !== void 0 || sb !== void 0) {
+    if (sa?.origin === "remote" || sb?.origin === "remote") {
+      merged[kStorageUpdateSource] = { origin: "remote" };
+    } else if (sa?.via === "history" || sb?.via === "history") {
+      const historySource = sb?.via === "history" ? sb : sa?.via === "history" ? sa : void 0;
+      if (historySource?.via === "history") {
+        merged[kStorageUpdateSource] = historySource;
+      }
+    } else {
+      merged[kStorageUpdateSource] = { origin: "local", via: "mutation" };
+    }
   }
-  return second;
+  return merged;
 }
 
 // src/devtools/bridge.ts
@@ -9925,6 +11104,8 @@ function createRoom(options, config) {
     activeBatch: null,
     unacknowledgedOps
   };
+  let nextHistoryItemId = 0;
+  let historyDisabled = 0;
   const nodeMapBuffer = makeNodeMapBuffer();
   const stopwatch = config.enableDebugLogging ? makeStopWatch() : void 0;
   let lastTokenKey;
@@ -10009,7 +11190,10 @@ function createRoom(options, config) {
       }
     }
   });
-  function onDispatch(ops, reverse, storageUpdates) {
+  function onDispatch(ops, reverse, storageUpdates, options2) {
+    for (const value of storageUpdates.values()) {
+      value[kStorageUpdateSource] = { origin: "local", via: "mutation" };
+    }
     if (context.activeBatch) {
       for (const op of ops) {
         context.activeBatch.ops.push(op);
@@ -10028,8 +11212,10 @@ function createRoom(options, config) {
       if (reverse.length > 0) {
         addToUndoStack(reverse);
       }
+      if (options2?.clearRedoStack ?? ops.length > 0) {
+        clearRedoStack();
+      }
       if (ops.length > 0) {
-        context.redoStack.length = 0;
         dispatchOps(ops);
       }
       notify({ storageUpdates });
@@ -10049,6 +11235,7 @@ function createRoom(options, config) {
     others: makeEventSource(),
     storageBatch: makeEventSource(),
     history: makeEventSource(),
+    privateHistory: makeEventSource(),
     storageDidLoad: makeEventSource(),
     storageStatus: makeEventSource(),
     ydoc: makeEventSource(),
@@ -10141,6 +11328,23 @@ function createRoom(options, config) {
       }
       const ops = diffNodeMap(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(
@@ -10164,11 +11368,26 @@ function createRoom(options, config) {
       }
     });
   }
+  function notifyPrivateHistory(event) {
+    if (historyDisabled > 0) return;
+    eventHub.privateHistory.notify(event);
+  }
+  function clearRedoStack() {
+    if (context.redoStack.length === 0) return;
+    const ids = context.redoStack.map((item) => item.id);
+    context.redoStack.length = 0;
+    notifyPrivateHistory({ action: "discard", ids });
+  }
   function _addToRealUndoStack(frames) {
     if (context.undoStack.length >= 50) {
-      context.undoStack.shift();
+      const evicted = context.undoStack.shift();
+      if (evicted !== void 0) {
+        notifyPrivateHistory({ action: "discard", ids: [evicted.id] });
+      }
     }
-    context.undoStack.push(frames);
+    const id = nextHistoryItemId++;
+    context.undoStack.push({ id, frames });
+    notifyPrivateHistory({ action: "push", id });
     onHistoryChange();
   }
   function addToUndoStack(frames) {
@@ -10206,7 +11425,7 @@ function createRoom(options, config) {
       "Internal. Tried to get connection id but connection was never open"
     );
   }
-  function applyLocalOps(frames) {
+  function applyLocalOps(frames, localStorageUpdateSource = { origin: "local", via: "mutation" }) {
     const [pframes, ops] = partition(
       frames,
       (f) => f.type === "presence"
@@ -10218,7 +11437,8 @@ function createRoom(options, config) {
       pframes,
       opsWithOpIds,
       /* isLocal */
-      true
+      true,
+      localStorageUpdateSource
     );
     return { opsToEmit: opsWithOpIds, reverse, updates };
   }
@@ -10230,7 +11450,7 @@ function createRoom(options, config) {
       false
     );
   }
-  function applyOps(pframes, ops, isLocal) {
+  function applyOps(pframes, ops, isLocal, localStorageUpdateSource = { origin: "local", via: "mutation" }) {
     const output = {
       reverse: new Deque(),
       storageUpdates: /* @__PURE__ */ new Map(),
@@ -10268,6 +11488,7 @@ function createRoom(options, config) {
       }
       const applyOpResult = applyOp(op, source);
       if (applyOpResult.modified) {
+        applyOpResult.modified[kStorageUpdateSource] = source === 1 /* THEIRS */ ? { origin: "remote" } : localStorageUpdateSource;
         const nodeId = applyOpResult.modified.node._id;
         if (!(nodeId && createdNodeIds.has(nodeId))) {
           output.storageUpdates.set(
@@ -10279,7 +11500,7 @@ function createRoom(options, config) {
           );
           output.reverse.pushLeft(applyOpResult.reverse);
         }
-        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT) {
+        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_TEXT) {
           createdNodeIds.add(op.id);
         }
       }
@@ -10299,6 +11520,7 @@ function createRoom(options, config) {
     switch (op.type) {
       case OpCode.DELETE_OBJECT_KEY:
       case OpCode.UPDATE_OBJECT:
+      case OpCode.UPDATE_TEXT:
       case OpCode.DELETE_CRDT: {
         const node = context.pool.nodes.get(op.id);
         if (node === void 0) {
@@ -10323,6 +11545,7 @@ function createRoom(options, config) {
       case OpCode.CREATE_OBJECT:
       case OpCode.CREATE_LIST:
       case OpCode.CREATE_MAP:
+      case OpCode.CREATE_TEXT:
       case OpCode.CREATE_REGISTER: {
         if (op.parentId === void 0) {
           return { modified: false };
@@ -10572,16 +11795,37 @@ 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();
+            flushNowOrSoon();
+          } else if (process.env.NODE_ENV !== "production") {
             throw new Error(
               `Storage mutations rejected by server: ${message.reason}`
             );
@@ -11123,14 +12367,19 @@ function createRoom(options, config) {
     if (context.activeBatch) {
       throw new Error("undo is not allowed during a batch");
     }
-    const frames = context.undoStack.pop();
-    if (frames === void 0) {
+    const item = context.undoStack.pop();
+    if (item === void 0) {
       return;
     }
     context.pausedHistory = null;
-    const result = applyLocalOps(frames);
+    const result = applyLocalOps(item.frames, {
+      origin: "local",
+      via: "history",
+      action: "undo"
+    });
+    context.redoStack.push({ id: item.id, frames: result.reverse });
+    notifyPrivateHistory({ action: "undo", id: item.id });
     notify(result.updates);
-    context.redoStack.push(result.reverse);
     onHistoryChange();
     for (const op of result.opsToEmit) {
       context.buffer.storageOperations.push(op);
@@ -11141,14 +12390,19 @@ function createRoom(options, config) {
     if (context.activeBatch) {
       throw new Error("redo is not allowed during a batch");
     }
-    const frames = context.redoStack.pop();
-    if (frames === void 0) {
+    const item = context.redoStack.pop();
+    if (item === void 0) {
       return;
     }
     context.pausedHistory = null;
-    const result = applyLocalOps(frames);
+    const result = applyLocalOps(item.frames, {
+      origin: "local",
+      via: "history",
+      action: "redo"
+    });
+    context.undoStack.push({ id: item.id, frames: result.reverse });
+    notifyPrivateHistory({ action: "redo", id: item.id });
     notify(result.updates);
-    context.undoStack.push(result.reverse);
     onHistoryChange();
     for (const op of result.opsToEmit) {
       context.buffer.storageOperations.push(op);
@@ -11158,6 +12412,8 @@ function createRoom(options, config) {
   function clear() {
     context.undoStack.length = 0;
     context.redoStack.length = 0;
+    notifyPrivateHistory({ action: "clear" });
+    onHistoryChange();
   }
   function batch2(callback) {
     if (context.activeBatch) {
@@ -11186,7 +12442,7 @@ function createRoom(options, config) {
         commitPausedHistoryToUndoStack();
       }
       if (currentBatch.ops.length > 0) {
-        context.redoStack.length = 0;
+        clearRedoStack();
       }
       if (currentBatch.ops.length > 0) {
         dispatchOps(currentBatch.ops);
@@ -11215,7 +12471,6 @@ function createRoom(options, config) {
     }
     commitPausedHistoryToUndoStack();
   }
-  let historyDisabled = 0;
   function disableHistory(fn) {
     const origUndo = context.undoStack;
     const origRedo = context.redoStack;
@@ -11454,13 +12709,28 @@ function createRoom(options, config) {
         },
         // prettier-ignore
         get undoStack() {
-          return deepClone(context.undoStack);
+          return structuredClone(
+            context.undoStack.map((item) => ({
+              id: item.id,
+              frames: item.frames
+            }))
+          );
+        },
+        // prettier-ignore
+        get redoStack() {
+          return structuredClone(
+            context.redoStack.map((item) => ({
+              id: item.id,
+              frames: item.frames
+            }))
+          );
         },
         // prettier-ignore
         get nodeCount() {
           return context.pool.nodes.size;
         },
         // prettier-ignore
+        history: eventHub.privateHistory.observable,
         getYjsProvider() {
           return context.yjsProvider;
         },
@@ -12480,6 +13750,12 @@ function toPlainLson(lson) {
       liveblocksType: "LiveList",
       data: [...lson].map((item) => toPlainLson(item))
     };
+  } else if (lson instanceof LiveText) {
+    return {
+      liveblocksType: "LiveText",
+      data: lson.toJSON(),
+      version: lson.version
+    };
   } else {
     return lson;
   }
@@ -12661,6 +13937,7 @@ export {
   LiveList,
   LiveMap,
   LiveObject,
+  LiveText,
   LiveblocksError,
   MENTION_CHARACTER,
   MutableSignal,
@@ -12672,6 +13949,7 @@ export {
   SortedList,
   TextEditorType,
   WebsocketCloseCodes,
+  applyLiveTextOperations,
   asPos,
   assert,
   assertNever,
@@ -12729,8 +14007,10 @@ export {
   isRegisterStorageNode,
   isRootStorageNode,
   isStartsWithOperator,
+  isTextStorageNode,
   isUrl,
   kInternal,
+  kStorageUpdateSource,
   keys,
   makeAbortController,
   makeEventSource,
@@ -12757,6 +14037,7 @@ export {
   stringifyCommentBody,
   throwUsageError,
   toPlainLson,
+  transformTextOperations,
   tryParseJson,
   url,
   urljoin,