@liveblocks/core 3.19.5-rc1 → 3.20.0-exp2

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.19.5-rc1";
+var PKG_VERSION = "3.20.0-exp2";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -5511,7 +5511,9 @@ 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";
@@ -5525,7 +5527,8 @@ var CrdtType = Object.freeze({
   OBJECT: 0,
   LIST: 1,
   MAP: 2,
-  REGISTER: 3
+  REGISTER: 3,
+  TEXT: 4
 });
 function isRootStorageNode(node) {
   return node[0] === "root";
@@ -5542,6 +5545,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";
 }
@@ -5564,6 +5570,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:
     }
   }
@@ -5592,6 +5601,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 {
     }
   }
@@ -7928,6 +7948,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       const id = nn(this._id);
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(id, parentKey);
+      const deletedItem = liveNodeToLson(child);
       for (const [key, value] of this.#synced) {
         if (value === child) {
           this.#synced.delete(key);
@@ -7939,7 +7960,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         node: this,
         type: "LiveObject",
         updates: {
-          [parentKey]: { type: "delete" }
+          [parentKey]: { type: "delete", deletedItem }
         }
       };
       return { modified: storageUpdate, reverse };
@@ -8426,6 +8447,583 @@ 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 deltaToSegments(delta) {
+  return normalizeSegments(
+    delta.map((item) => ({
+      text: item.text,
+      attributes: item.attributes
+    }))
+  );
+}
+function segmentsToDelta(segments) {
+  return segments.map(
+    (segment) => segment.attributes === void 0 ? { text: segment.text } : { text: segment.text, attributes: { ...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 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 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(delta, ops) {
+  return segmentsToDelta(
+    applyTextOperationsToSegments(deltaToSegments(delta), 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 LiveText = class _LiveText extends AbstractCrdt {
+  #segments;
+  #version;
+  #pendingOps;
+  constructor(textOrDelta = "", version = 0) {
+    super();
+    this.#segments = typeof textOrDelta === "string" ? textOrDelta.length === 0 ? [] : [{ text: textOrDelta }] : deltaToSegments(textOrDelta);
+    this.#version = version;
+    this.#pendingOps = /* @__PURE__ */ new Map();
+  }
+  get version() {
+    return this.#version;
+  }
+  get length() {
+    return this.toString().length;
+  }
+  /** @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.toDelta(),
+        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.toDelta(),
+      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) {
+      this.#pendingOps.set(nn(op.opId), op.ops);
+      return this.#applyOperations(op.ops, 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,
+          op.version ?? Math.max(this.#version, op.baseVersion + 1)
+        );
+      }
+      this.#version = op.version ?? Math.max(this.#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, op.version ?? this.#version + 1);
+  }
+  insert(index, text, attributes) {
+    const clippedIndex = Math.max(0, Math.min(index, this.length));
+    this.#dispatch([{ type: "insert", index: clippedIndex, text, attributes }]);
+  }
+  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 }
+    ]);
+  }
+  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);
+  }
+  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
+      }
+    ]);
+  }
+  #dispatch(ops) {
+    if (ops.length === 0) {
+      return;
+    }
+    this._pool?.assertStorageIsWritable();
+    const baseVersion = this.#version;
+    const reverse = this._pool !== void 0 && this._id !== void 0 ? 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(
+        [
+          {
+            type: OpCode.UPDATE_TEXT,
+            id: this._id,
+            opId,
+            baseVersion,
+            ops: [...ops]
+          }
+        ],
+        reverse,
+        /* @__PURE__ */ new Map([
+          [
+            this._id,
+            {
+              type: "LiveText",
+              node: this,
+              version: this.#version,
+              updates: changes
+            }
+          ]
+        ])
+      );
+    }
+  }
+  #applyOperations(ops, version) {
+    const reverse = this.#invertOperations(ops);
+    const changes = this.#applyOperationsLocally(ops);
+    this.#version = Math.max(this.#version, version);
+    return {
+      reverse,
+      modified: {
+        type: "LiveText",
+        node: this,
+        version: this.#version,
+        updates: changes
+      }
+    };
+  }
+  #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)
+      }
+    ];
+  }
+  toString() {
+    return this.#segments.map((segment) => segment.text).join("");
+  }
+  toDelta() {
+    return segmentsToDelta(this.#segments);
+  }
+  toJSON() {
+    return super.toJSON();
+  }
+  /** @internal */
+  _toJSON() {
+    return this.toDelta();
+  }
+  /** @internal */
+  _toTreeNode(key) {
+    return {
+      type: "LiveText",
+      id: this._id ?? nanoid(),
+      key,
+      payload: [
+        {
+          type: "Json",
+          id: `${this._id ?? nanoid()}:text`,
+          key: "text",
+          payload: this.toString()
+        }
+      ]
+    };
+  }
+  clone() {
+    return new _LiveText(this.toDelta(), this.#version);
+  }
+};
+
 // src/crdts/liveblocks-helpers.ts
 function creationOpToLiveNode(op) {
   return lsonToLiveNode(creationOpToLson(op));
@@ -8440,6 +9038,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");
   }
@@ -8462,6 +9062,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");
   }
@@ -8475,12 +9077,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);
@@ -8494,6 +9098,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;
 }
@@ -8503,14 +9110,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);
@@ -8541,6 +9148,35 @@ function dumpPool(pool) {
     (r) => `  ${r.id}  parent=${r.parentId}  key=${r.key || "\u2014"}  ${r.value}`
   ).join("\n");
 }
+function isJsonEq(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!isJsonEq(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!isJsonEq(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
 function getTreesDiffOperations(currentItems, newItems) {
   const ops = [];
   currentItems.forEach((_, id) => {
@@ -8552,11 +9188,59 @@ function getTreesDiffOperations(currentItems, newItems) {
     const currentCrdt = currentItems.get(id);
     if (currentCrdt) {
       if (crdt.type === CrdtType.OBJECT) {
-        if (currentCrdt.type !== CrdtType.OBJECT || stringifyOrLog(crdt.data) !== stringifyOrLog(currentCrdt.data)) {
+        if (currentCrdt.type !== CrdtType.OBJECT) {
+          ops.push({ type: OpCode.UPDATE_OBJECT, id, data: crdt.data });
+        } else {
+          const changed = /* @__PURE__ */ new Map();
+          for (const key of Object.keys(crdt.data)) {
+            const value = crdt.data[key];
+            if (value !== void 0 && !isJsonEq(value, currentCrdt.data[key])) {
+              changed.set(key, value);
+            }
+          }
+          if (changed.size > 0) {
+            ops.push({
+              type: OpCode.UPDATE_OBJECT,
+              id,
+              data: Object.fromEntries(changed)
+            });
+          }
+          for (const key of Object.keys(currentCrdt.data)) {
+            if (!(key in crdt.data)) {
+              ops.push({ type: OpCode.DELETE_OBJECT_KEY, id, key });
+            }
+          }
+        }
+      }
+      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_OBJECT,
+            type: OpCode.UPDATE_TEXT,
             id,
-            data: crdt.data
+            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, item) => sum + item.text.length,
+                  0
+                ) : 0
+              },
+              ...crdt.data.map(
+                (item, index, items) => item.attributes === void 0 ? {
+                  type: "insert",
+                  index: items.slice(0, index).reduce((sum, item2) => sum + item2.text.length, 0),
+                  text: item.text
+                } : {
+                  type: "insert",
+                  index: items.slice(0, index).reduce((sum, item2) => sum + item2.text.length, 0),
+                  text: item.text,
+                  attributes: item.attributes
+                }
+              )
+            ]
           });
         }
       }
@@ -8608,6 +9292,16 @@ function getTreesDiffOperations(currentItems, newItems) {
             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;
       }
     }
   });
@@ -8640,6 +9334,12 @@ 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;
@@ -8650,6 +9350,8 @@ function mergeStorageUpdates(first, second) {
     return mergeMapStorageUpdates(first, second);
   } else if (first.type === "LiveList" && second.type === "LiveList") {
     return mergeListStorageUpdates(first, second);
+  } else if (first.type === "LiveText" && second.type === "LiveText") {
+    return mergeTextStorageUpdates(first, second);
   } else {
   }
   return second;
@@ -9938,7 +10640,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);
         }
       }
@@ -9958,6 +10660,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) {
@@ -9982,6 +10685,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 };
@@ -12141,6 +12845,12 @@ function toPlainLson(lson) {
       liveblocksType: "LiveList",
       data: [...lson].map((item) => toPlainLson(item))
     };
+  } else if (lson instanceof LiveText) {
+    return {
+      liveblocksType: "LiveText",
+      data: lson.toDelta(),
+      version: lson.version
+    };
   } else {
     return lson;
   }
@@ -12322,6 +13032,7 @@ export {
   LiveList,
   LiveMap,
   LiveObject,
+  LiveText,
   LiveblocksError,
   MENTION_CHARACTER,
   MutableSignal,
@@ -12333,6 +13044,7 @@ export {
   SortedList,
   TextEditorType,
   WebsocketCloseCodes,
+  applyLiveTextOperations,
   asPos,
   assert,
   assertNever,
@@ -12388,6 +13100,7 @@ export {
   isRegisterStorageNode,
   isRootStorageNode,
   isStartsWithOperator,
+  isTextStorageNode,
   isUrl,
   kInternal,
   keys,