@liveblocks/core 3.19.4-test1 → 3.20.0-pre1

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.4-test1";
+var PKG_VERSION = "3.20.0-pre1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -2715,6 +2715,7 @@ var HttpClient = class {
 };
 
 // src/lib/fsm.ts
+var IGNORE = /* @__PURE__ */ Symbol("fsm.ignore");
 function distance(state1, state2) {
   if (state1 === state2) {
     return [0, 0];
@@ -2887,7 +2888,7 @@ var FSM = class {
     this.#eventHub = {
       didReceiveEvent: makeEventSource(),
       willTransition: makeEventSource(),
-      didIgnoreEvent: makeEventSource(),
+      didIgnoreUnexpectedEvent: makeEventSource(),
       willExitState: makeEventSource(),
       didEnterState: makeEventSource(),
       didExitState: makeEventSource()
@@ -2895,7 +2896,7 @@ var FSM = class {
     this.events = {
       didReceiveEvent: this.#eventHub.didReceiveEvent.observable,
       willTransition: this.#eventHub.willTransition.observable,
-      didIgnoreEvent: this.#eventHub.didIgnoreEvent.observable,
+      didIgnoreUnexpectedEvent: this.#eventHub.didIgnoreUnexpectedEvent.observable,
       willExitState: this.#eventHub.willExitState.observable,
       didEnterState: this.#eventHub.didEnterState.observable,
       didExitState: this.#eventHub.didExitState.observable
@@ -3018,9 +3019,14 @@ var FSM = class {
    * `context` params to conditionally decide which next state to transition
    * to.
    *
-   * If you set it to `null`, then the transition will be explicitly forbidden
-   * and throw an error. If you don't define a target for a transition, then
-   * such events will get ignored.
+   * If you don't define a target for a transition, the event is treated
+   * as unhandled in this state: `didIgnoreUnexpectedEvent` fires and the
+   * state does not change.
+   *
+   * To declare an event as an intentional silent no-op in this state, use
+   * the {@link IGNORE} sentinel — either statically (`{ EVENT: IGNORE }`)
+   * or as a return value from a target function. IGNORE'd events do not
+   * fire `didIgnoreUnexpectedEvent`.
    */
   addTransitions(nameOrPattern, mapping) {
     if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
@@ -3040,7 +3046,12 @@ var FSM = class {
         }
         const target = target_;
         this.#knownEventTypes.add(type);
-        if (target !== void 0) {
+        if (target === void 0) {
+          continue;
+        }
+        if (target === IGNORE) {
+          map.set(type, IGNORE);
+        } else {
           const targetFn = typeof target === "function" ? target : () => target;
           map.set(type, targetFn);
         }
@@ -3139,12 +3150,14 @@ var FSM = class {
     if (this.#runningState === 2 /* STOPPED */) {
       return;
     }
-    const targetFn = this.#getTargetFn(event.type);
-    if (targetFn !== void 0) {
-      return this.#transition(event, targetFn);
-    } else {
-      this.#eventHub.didIgnoreEvent.notify(event);
+    const entry = this.#getTargetFn(event.type);
+    if (entry === IGNORE) {
+      return;
+    }
+    if (entry !== void 0) {
+      return this.#transition(event, entry);
     }
+    this.#eventHub.didIgnoreUnexpectedEvent.notify(event);
   }
   #transition(event, target) {
     this.#eventHub.didReceiveEvent.notify(event);
@@ -3153,8 +3166,7 @@ var FSM = class {
     const nextTarget = targetFn(event, this.#currentContext.current);
     let nextState;
     let effects = void 0;
-    if (nextTarget === null) {
-      this.#eventHub.didIgnoreEvent.notify(event);
+    if (nextTarget === IGNORE) {
       return;
     }
     if (typeof nextTarget === "string") {
@@ -3373,8 +3385,8 @@ function enableTracing(machine) {
     machine.events.didExitState.subscribe(
       ({ state, durationMs }) => log2(`Exited ${state} after ${durationMs.toFixed(0)}ms`)
     ),
-    machine.events.didIgnoreEvent.subscribe(
-      (e) => log2("Ignored event", e.type, e, "(current state won't handle it)")
+    machine.events.didIgnoreUnexpectedEvent.subscribe(
+      (e) => log2("Ignored unexpected event", e.type, e, "(no transition declared)")
     )
   ];
   return () => {
@@ -3486,7 +3498,12 @@ function createConnectionStateMachine(delegates, options) {
   );
   const onSocketError = (event) => machine.send({ type: "EXPLICIT_SOCKET_ERROR", event });
   const onSocketClose = (event) => machine.send({ type: "EXPLICIT_SOCKET_CLOSE", event });
-  const onSocketMessage = (event) => event.data === "pong" ? machine.send({ type: "PONG" }) : onMessage.notify(event);
+  const onSocketMessage = (event) => {
+    machine.send({ type: "ALIVE" });
+    if (event.data !== "pong") {
+      onMessage.notify(event);
+    }
+  };
   function teardownSocket(socket) {
     if (socket) {
       socket.removeEventListener("error", onSocketError);
@@ -3656,7 +3673,13 @@ function createConnectionStateMachine(delegates, options) {
         effect: [increaseBackoffDelay, logPrematureErrorOrCloseEvent(err)]
       };
     }
-  );
+  ).addTransitions("@connecting.busy", {
+    // The socket message listener is attached during @connecting.busy (see
+    // onEnterAsync above), so server frames (most notably the actor-id
+    // handshake) can fire onSocketMessage and emit a ALIVE before we
+    // reach @ok.*. That's fine. Heartbeat only matters in @ok.*.
+    ALIVE: IGNORE
+  });
   const sendHeartbeat = {
     target: "@ok.awaiting-pong",
     effect: (ctx) => {
@@ -3671,7 +3694,8 @@ function createConnectionStateMachine(delegates, options) {
   machine.addTimedTransition("@ok.connected", HEARTBEAT_INTERVAL, maybeHeartbeat).addTransitions("@ok.connected", {
     NAVIGATOR_OFFLINE: maybeHeartbeat,
     // Don't take the browser's word for it when it says it's offline. Do a ping/pong to make sure.
-    WINDOW_GOT_FOCUS: sendHeartbeat
+    WINDOW_GOT_FOCUS: sendHeartbeat,
+    ALIVE: IGNORE
   });
   machine.addTransitions("@idle.zombie", {
     WINDOW_GOT_FOCUS: "@connecting.backoff"
@@ -3692,7 +3716,7 @@ function createConnectionStateMachine(delegates, options) {
       clearTimeout(timerID);
       onMessage.pause();
     };
-  }).addTransitions("@ok.awaiting-pong", { PONG: "@ok.connected" }).addTimedTransition("@ok.awaiting-pong", PONG_TIMEOUT, {
+  }).addTransitions("@ok.awaiting-pong", { ALIVE: "@ok.connected" }).addTimedTransition("@ok.awaiting-pong", PONG_TIMEOUT, {
     target: "@connecting.busy",
     // Log implicit connection loss and drop the current open socket
     effect: log(
@@ -3705,7 +3729,7 @@ function createConnectionStateMachine(delegates, options) {
     // not. When still OPEN, don't transition.
     EXPLICIT_SOCKET_ERROR: (_, context) => {
       if (context.socket?.readyState === 1) {
-        return null;
+        return IGNORE;
       }
       return {
         target: "@connecting.backoff",
@@ -5473,9 +5497,7 @@ var OpCode = Object.freeze({
   DELETE_CRDT: 5,
   DELETE_OBJECT_KEY: 6,
   CREATE_MAP: 7,
-  CREATE_REGISTER: 8,
-  CREATE_TEXT: 9,
-  UPDATE_TEXT: 10
+  CREATE_REGISTER: 8
 });
 function isIgnoredOp(op) {
   return op.type === OpCode.DELETE_CRDT && op.id === "ACK";
@@ -5486,8 +5508,7 @@ var CrdtType = Object.freeze({
   OBJECT: 0,
   LIST: 1,
   MAP: 2,
-  REGISTER: 3,
-  TEXT: 4
+  REGISTER: 3
 });
 function isRootStorageNode(node) {
   return node[0] === "root";
@@ -5504,9 +5525,6 @@ 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";
 }
@@ -5529,9 +5547,6 @@ 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:
     }
   }
@@ -5560,17 +5575,6 @@ 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 {
     }
   }
@@ -6119,9 +6123,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     ops.push(op);
     for (const item of this.#items) {
       const parentKey2 = item._getParentKeyOrThrow();
-      const childOps = HACK_addIntentAndDeletedIdToOperation(
+      const childOps = addIntentToOpTree(
         item._toOps(this._id, parentKey2),
-        void 0
+        "set"
       );
       for (const childOp of childOps) {
         ops.push(childOp);
@@ -6435,8 +6439,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
       existingItem._detach();
       this.#items.remove(existingItem);
       this.#items.add(child);
-      const reverse = HACK_addIntentAndDeletedIdToOperation(
+      const reverse = addIntentToOpTree(
         existingItem._toOps(nn(this._id), key),
+        "set",
         op.id
       );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
@@ -6679,8 +6684,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    this._pool?.assertStorageIsWritable();
-    return this.insert(element, this.length);
+    return this.#injectAt(element, this.length, "push");
   }
   /**
    * Inserts one element at a specified index.
@@ -6688,6 +6692,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
+    return this.#injectAt(element, index, "insert");
+  }
+  /**
+   * Shared implementation of `insert` and `push`. A `"push"` intent leaves the
+   * client-computed position untouched (so optimistic rendering is unchanged),
+   * but tags the Op so the server appends it to the true end of the list
+   * instead of resolving its position against the client's stale view.
+   */
+  #injectAt(element, index, intent) {
     this._pool?.assertStorageIsWritable();
     if (index < 0 || index > this.#items.length) {
       throw new Error(
@@ -6703,8 +6716,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool && this._id) {
       const id = this._pool.generateId();
       value._attach(id, this._pool);
+      const ops = value._toOpsWithOpId(this._id, position, this._pool);
       this._pool.dispatch(
-        value._toOpsWithOpId(this._id, position, this._pool),
+        intent === "push" ? addIntentToOpTree(ops, "push") : ops,
         [{ type: OpCode.DELETE_CRDT, id }],
         /* @__PURE__ */ new Map([
           [this._id, makeUpdate(this, [insertDelta(index, value)])]
@@ -6862,13 +6876,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
       value._attach(id, this._pool);
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, makeUpdate(this, [setDelta(index, value)]));
-      const ops = HACK_addIntentAndDeletedIdToOperation(
+      const ops = addIntentToOpTree(
         value._toOpsWithOpId(this._id, position, this._pool),
+        "set",
         existingId
       );
       this.#unacknowledgedSets.set(position, nn(ops[0].opId));
-      const reverseOps = HACK_addIntentAndDeletedIdToOperation(
+      const reverseOps = addIntentToOpTree(
         existingItem._toOps(this._id, position),
+        "set",
         id
       );
       this._pool.dispatch(ops, reverseOps, storageUpdates);
@@ -7069,15 +7085,11 @@ function moveDelta(previousIndex, index, item) {
     previousIndex
   };
 }
-function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
+function addIntentToOpTree(ops, intent, deletedId) {
   return ops.map((op, index) => {
     if (index === 0) {
       const firstOp = op;
-      return {
-        ...firstOp,
-        intent: "set",
-        deletedId
-      };
+      return { ...firstOp, intent, deletedId };
     } else {
       return op;
     }
@@ -8227,581 +8239,6 @@ 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));
@@ -8816,8 +8253,6 @@ 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");
   }
@@ -8840,8 +8275,6 @@ 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");
   }
@@ -8855,14 +8288,12 @@ 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) || isLiveText(value);
+  return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
 }
 function isLiveNode(value) {
   return isLiveStructure(value) || isLiveRegister(value);
@@ -8876,9 +8307,6 @@ function isLiveMap(value) {
 function isLiveObject(value) {
   return value instanceof LiveObject;
 }
-function isLiveText(value) {
-  return value instanceof LiveText;
-}
 function isLiveRegister(value) {
   return value instanceof LiveRegister;
 }
@@ -8888,14 +8316,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 || obj instanceof LiveText) {
+  } else if (obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject) {
     return obj;
   } else {
     return assertNever(obj, "Unknown AbstractCrdt");
   }
 }
 function lsonToLiveNode(value) {
-  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList || value instanceof LiveText) {
+  if (value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList) {
     return value;
   } else {
     return new LiveRegister(value);
@@ -8920,38 +8348,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, 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
-                }
-              )
-            ]
-          });
-        }
-      }
       if (crdt.parentKey !== currentCrdt.parentKey) {
         ops.push({
           type: OpCode.SET_PARENT_KEY,
@@ -9000,16 +8396,6 @@ 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;
       }
     }
   });
@@ -9042,12 +8428,6 @@ 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;
@@ -9058,8 +8438,6 @@ 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;
@@ -10341,7 +9719,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 || op.type === OpCode.CREATE_TEXT) {
+        if (op.type === OpCode.CREATE_LIST || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_OBJECT) {
           createdNodeIds.add(op.id);
         }
       }
@@ -10361,7 +9739,6 @@ 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) {
@@ -10386,7 +9763,6 @@ 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 };
@@ -12541,12 +11917,6 @@ 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;
   }
@@ -12728,7 +12098,6 @@ export {
   LiveList,
   LiveMap,
   LiveObject,
-  LiveText,
   LiveblocksError,
   MENTION_CHARACTER,
   MutableSignal,
@@ -12740,7 +12109,6 @@ export {
   SortedList,
   TextEditorType,
   WebsocketCloseCodes,
-  applyLiveTextOperations,
   asPos,
   assert,
   assertNever,
@@ -12796,7 +12164,6 @@ export {
   isRegisterStorageNode,
   isRootStorageNode,
   isStartsWithOperator,
-  isTextStorageNode,
   isUrl,
   kInternal,
   keys,