@liveblocks/core 3.19.3 → 3.19.5-rc1

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.3";
+var PKG_VERSION = "3.19.5-rc1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -701,6 +701,20 @@ var SortedList = class _SortedList {
   get length() {
     return this.#data.length;
   }
+  /**
+   * Whether the given value is present, by identity. O(log n) plus the length
+   * of any run of items that share its sort key (normally 1). Bisects on the
+   * value's own key, so it only finds values sitting at their sorted position,
+   * which is true for any item currently in the list.
+   */
+  includes(value) {
+    for (let i = bisectRight(this.#data, value, this.#lt) - 1; i >= 0 && !this.#lt(this.#data[i], value); i--) {
+      if (this.#data[i] === value) {
+        return true;
+      }
+    }
+    return false;
+  }
   *filter(predicate) {
     for (const item of this.#data) {
       if (predicate(item)) {
@@ -5502,6 +5516,9 @@ var OpCode = Object.freeze({
 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;
+}
 
 // src/protocol/StorageNode.ts
 var CrdtType = Object.freeze({
@@ -5759,12 +5776,95 @@ function asPos(str) {
   return isPos(str) ? str : convertToPos(str);
 }
 
+// src/crdts/UnacknowledgedOps.ts
+var UnacknowledgedOps = class {
+  // opId -> op
+  #byOpId = /* @__PURE__ */ new Map();
+  // position -> (opId -> Create op)
+  #createOpsByPosition = /* @__PURE__ */ new Map();
+  // parentId -> (opId -> Create op)
+  #createOpsByParent = /* @__PURE__ */ new Map();
+  #posKey(parentId, parentKey) {
+    return `${parentId}
+${parentKey}`;
+  }
+  get size() {
+    return this.#byOpId.size;
+  }
+  /**
+   * Mark the given Op as still unacknowledged.
+   */
+  add(op) {
+    this.#byOpId.set(op.opId, op);
+    if (isCreateOp(op)) {
+      const posKey = this.#posKey(op.parentId, op.parentKey);
+      let atPosition = this.#createOpsByPosition.get(posKey);
+      if (atPosition === void 0) {
+        atPosition = /* @__PURE__ */ new Map();
+        this.#createOpsByPosition.set(posKey, atPosition);
+      }
+      atPosition.set(op.opId, op);
+      let inParent = this.#createOpsByParent.get(op.parentId);
+      if (inParent === void 0) {
+        inParent = /* @__PURE__ */ new Map();
+        this.#createOpsByParent.set(op.parentId, inParent);
+      }
+      inParent.set(op.opId, op);
+    }
+  }
+  /**
+   * Drop the op with the given opId from the set, because the server has
+   * acknowledged it (confirmed our own op, or signalled it was seen but
+   * ignored).
+   */
+  delete(opId) {
+    const op = this.#byOpId.get(opId);
+    if (op === void 0) {
+      return;
+    }
+    this.#byOpId.delete(opId);
+    if (isCreateOp(op)) {
+      const posKey = this.#posKey(op.parentId, op.parentKey);
+      const atPosition = this.#createOpsByPosition.get(posKey);
+      atPosition?.delete(opId);
+      if (atPosition !== void 0 && atPosition.size === 0) {
+        this.#createOpsByPosition.delete(posKey);
+      }
+      const inParent = this.#createOpsByParent.get(op.parentId);
+      inParent?.delete(opId);
+      if (inParent !== void 0 && inParent.size === 0) {
+        this.#createOpsByParent.delete(op.parentId);
+      }
+    }
+  }
+  /**
+   * The still-unacknowledged Create ops with the given `parentId` and
+   * `parentKey` (targeting one exact position), in dispatch order. O(1) lookup.
+   * Empty if none.
+   */
+  getByParentIdAndKey(parentId, parentKey) {
+    return this.#createOpsByPosition.get(this.#posKey(parentId, parentKey))?.values() ?? [];
+  }
+  /**
+   * The still-unacknowledged Create ops with the given `parentId` (across all
+   * positions), in dispatch order. O(1) lookup. Empty if none.
+   */
+  getByParentId(parentId) {
+    return this.#createOpsByParent.get(parentId)?.values() ?? [];
+  }
+  /** All still-unacknowledged ops, in dispatch order. */
+  values() {
+    return this.#byOpId.values();
+  }
+};
+
 // src/crdts/AbstractCrdt.ts
 function createManagedPool(roomId, options) {
   const {
     getCurrentConnectionId,
     onDispatch,
-    isStorageWritable = () => true
+    isStorageWritable = () => true,
+    unacknowledgedOps = new UnacknowledgedOps()
   } = options;
   let clock = 0;
   let opClock = 0;
@@ -5786,7 +5886,8 @@ function createManagedPool(roomId, options) {
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
       }
-    }
+    },
+    unacknowledgedOps
   };
 }
 function crdtAsLiveNode(value) {
@@ -6068,11 +6169,9 @@ function childNodeLt(a, b) {
 var LiveList = class _LiveList extends AbstractCrdt {
   #items;
   #implicitlyDeletedItems;
-  #unacknowledgedSets;
   constructor(items) {
     super();
     this.#implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
-    this.#unacknowledgedSets = /* @__PURE__ */ new Map();
     const nodes = [];
     let lastPos;
     for (const item of items) {
@@ -6102,12 +6201,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /**
    * @internal
-   * This function assumes that the resulting ops will be sent to the server if they have an 'opId'
-   * so we mutate _unacknowledgedSets to avoid potential flickering
-   * https://github.com/liveblocks/liveblocks/pull/1177
+   * Serializes this list (and its children) into Create ops. Each child's
+   * create is tagged with the "set" intent (in the loop below) so that a list
+   * created and immediately mutated doesn't transiently re-show its initial
+   * items (flicker, https://github.com/liveblocks/liveblocks/pull/1177).
    *
-   * This is quite unintuitive and should disappear as soon as
-   * we introduce an explicit LiveList.Set operation
+   * This is quite unintuitive and should disappear as soon as we introduce an
+   * explicit LiveList.Set operation.
    */
   _toOps(parentId, parentKey) {
     if (this._id === void 0) {
@@ -6123,9 +6223,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 = addIntentToRootOp(
         item._toOps(this._id, parentKey2),
-        void 0
+        "set"
       );
       for (const childOp of childOps) {
         ops.push(childOp);
@@ -6167,6 +6267,28 @@ var LiveList = class _LiveList extends AbstractCrdt {
       (item) => item._getParentKeyOrThrow() === position
     );
   }
+  /**
+   * The opId of this list's still-unacknowledged "set" op at the given position,
+   * or undefined if none. Derived from the room's unacknowledgedOps (the single
+   * source of truth) rather than tracked in a per-instance map. The pool's
+   * position index already scopes to this list's (parentId, position); the last
+   * match wins, matching the original last-write-wins map semantics.
+   */
+  #unacknowledgedSetOpIdAt(position) {
+    if (this._pool === void 0 || this._id === void 0) {
+      return void 0;
+    }
+    let opId;
+    for (const op of this._pool.unacknowledgedOps.getByParentIdAndKey(
+      this._id,
+      position
+    )) {
+      if (op.intent === "set") {
+        opId = op.opId;
+      }
+    }
+    return opId;
+  }
   /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
@@ -6247,13 +6369,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (deletedDelta) {
       delta.push(deletedDelta);
     }
-    const unacknowledgedOpId = this.#unacknowledgedSets.get(op.parentKey);
-    if (unacknowledgedOpId !== void 0) {
-      if (unacknowledgedOpId !== op.opId) {
-        return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
-      } else {
-        this.#unacknowledgedSets.delete(op.parentKey);
-      }
+    const unacknowledgedOpId = this.#unacknowledgedSetOpIdAt(op.parentKey);
+    if (unacknowledgedOpId !== void 0 && unacknowledgedOpId !== op.opId) {
+      return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
     }
     const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
     const existingItem = this.#items.find((item) => item._id === op.id);
@@ -6334,7 +6452,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     return result.modified.updates[0];
   }
-  #applyRemoteInsert(op) {
+  #applyRemoteInsert(op, fromSnapshot) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
@@ -6344,11 +6462,82 @@ var LiveList = class _LiveList extends AbstractCrdt {
       this.#shiftItemPosition(existingItemIndex, key);
     }
     const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
+    const bumpDeltas = fromSnapshot ? [] : this.#bumpUnackedPushesAbove(key);
     return {
-      modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
+      modified: makeUpdate(this, [
+        insertDelta(newIndex, newItem),
+        ...bumpDeltas
+      ]),
       reverse: []
     };
   }
+  /**
+   * This list's own still-unacknowledged pushed items (their `intent: "push"`
+   * Create op is still pending in the room's unacknowledgedOps). Derived from
+   * the single source of truth, so an item drops out the instant its op is
+   * acked, with no per-instance membership to leak. Yielded in push order.
+   *
+   * Restricted to items currently in `#items`: a pushed node whose op is still
+   * pending may have been pulled out of the list (e.g. implicitly deleted by a
+   * remote set, or removed by an undo) while still living in the pool, and such
+   * a node must not be repositioned.
+   */
+  *#unackedPushNodes() {
+    if (this._pool === void 0 || this._id === void 0) {
+      return;
+    }
+    for (const op of this._pool.unacknowledgedOps.getByParentId(this._id)) {
+      if (op.intent !== "push") {
+        continue;
+      }
+      const node = this._pool.getNode(op.id);
+      if (node !== void 0 && this.#items.includes(node)) {
+        yield node;
+      }
+    }
+  }
+  /**
+   * Optimistic no-flip for pushed items. When a remote op lands at or below my
+   * still-unacked pushed items, those items must end up *after* it: FIFO plus
+   * the room's serial processing guarantee the remote was processed first, so
+   * my unacked pushes belong behind it. Re-chain the whole unacked-push block,
+   * in push order, to sit after the highest confirmed sibling, so it keeps
+   * rendering as a contiguous tail instead of getting interleaved. Local-only;
+   * the real acks overwrite these keys with the (identical) server keys.
+   */
+  #bumpUnackedPushesAbove(remoteKey) {
+    const pending = new Set(this.#unackedPushNodes());
+    if (pending.size === 0) {
+      return [];
+    }
+    let minPending;
+    for (const node of pending) {
+      const pos = node._parentPos;
+      if (minPending === void 0 || pos < minPending) {
+        minPending = pos;
+      }
+    }
+    if (remoteKey < nn(minPending)) {
+      return [];
+    }
+    let base;
+    for (const item of this.#items) {
+      if (!pending.has(item)) {
+        base = item._parentPos;
+      }
+    }
+    const deltas = [];
+    for (const node of pending) {
+      const previousIndex = this.#items.findIndex((item) => item === node);
+      base = makePosition(base);
+      this.#updateItemPosition(node, base);
+      const index = this.#items.findIndex((item) => item === node);
+      if (index !== previousIndex) {
+        deltas.push(moveDelta(previousIndex, index, node));
+      }
+    }
+    return deltas;
+  }
   #applyInsertAck(op) {
     const existingItem = this.#items.find((item) => item._id === op.id);
     const key = asPos(op.parentKey);
@@ -6429,7 +6618,6 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool?.getNode(id) !== void 0) {
       return { modified: false };
     }
-    this.#unacknowledgedSets.set(key, nn(op.opId));
     const indexOfItemWithSameKey = this._indexOfPosition(key);
     child._attach(id, nn(this._pool));
     child._setParentLink(this, key);
@@ -6439,8 +6627,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
       existingItem._detach();
       this.#items.remove(existingItem);
       this.#items.add(child);
-      const reverse = HACK_addIntentAndDeletedIdToOperation(
+      const reverse = addIntentToRootOp(
         existingItem._toOps(nn(this._id), key),
+        "set",
         op.id
       );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
@@ -6465,7 +6654,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   /** @internal */
-  _attachChild(op, source) {
+  _attachChild(op, source, fromSnapshot = false) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
@@ -6480,7 +6669,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     } else {
       if (source === 1 /* THEIRS */) {
-        result = this.#applyRemoteInsert(op);
+        result = this.#applyRemoteInsert(op, fromSnapshot);
       } else if (source === 2 /* OURS */) {
         result = this.#applyInsertAck(op);
       } else {
@@ -6683,8 +6872,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.
@@ -6692,6 +6880,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(
@@ -6707,8 +6904,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" ? addIntentToRootOp(ops, "push") : ops,
         [{ type: OpCode.DELETE_CRDT, id }],
         /* @__PURE__ */ new Map([
           [this._id, makeUpdate(this, [insertDelta(index, value)])]
@@ -6866,13 +7064,14 @@ 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 = addIntentToRootOp(
         value._toOpsWithOpId(this._id, position, this._pool),
+        "set",
         existingId
       );
-      this.#unacknowledgedSets.set(position, nn(ops[0].opId));
-      const reverseOps = HACK_addIntentAndDeletedIdToOperation(
+      const reverseOps = addIntentToRootOp(
         existingItem._toOps(this._id, position),
+        "set",
         id
       );
       this._pool.dispatch(ops, reverseOps, storageUpdates);
@@ -7073,15 +7272,11 @@ function moveDelta(previousIndex, index, item) {
     previousIndex
   };
 }
-function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
+function addIntentToRootOp(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;
     }
@@ -8321,6 +8516,31 @@ function lsonToLiveNode(value) {
     return new LiveRegister(value);
   }
 }
+function dumpPool(pool) {
+  const rows = Array.from(pool.nodes.values(), (node) => {
+    const parent = node.parent;
+    const parentId = parent.type === "HasParent" ? parent.node._id ?? "?" : parent.type === "Orphaned" ? "<orphaned>" : "-";
+    let value;
+    if (node instanceof LiveRegister) {
+      value = stringifyOrLog(node.data);
+    } else if (node instanceof LiveList) {
+      value = "<LiveList>";
+    } else if (node instanceof LiveMap) {
+      value = "<LiveMap>";
+    } else {
+      value = "<LiveObject>";
+    }
+    return { id: nn(node._id), parentId, key: node._parentKey ?? "", value };
+  });
+  rows.sort((a, b) => {
+    if (a.parentId !== b.parentId) return a.parentId < b.parentId ? -1 : 1;
+    if (a.key !== b.key) return a.key < b.key ? -1 : 1;
+    return 0;
+  });
+  return rows.map(
+    (r) => `  ${r.id}  parent=${r.parentId}  key=${r.key || "\u2014"}  ${r.value}`
+  ).join("\n");
+}
 function getTreesDiffOperations(currentItems, newItems) {
   const ops = [];
   currentItems.forEach((_, id) => {
@@ -9330,6 +9550,7 @@ function createRoom(options, config) {
     delegates,
     config.enableDebugLogging
   );
+  const unacknowledgedOps = new UnacknowledgedOps();
   const context = {
     buffer: {
       flushTimerID: void 0,
@@ -9357,14 +9578,15 @@ function createRoom(options, config) {
     pool: createManagedPool(roomId, {
       getCurrentConnectionId,
       onDispatch,
-      isStorageWritable
+      isStorageWritable,
+      unacknowledgedOps
     }),
     root: void 0,
     undoStack: [],
     redoStack: [],
     pausedHistory: null,
     activeBatch: null,
-    unacknowledgedOps: /* @__PURE__ */ new Map()
+    unacknowledgedOps
   };
   const nodeMapBuffer = makeNodeMapBuffer();
   const stopwatch = config.enableDebugLogging ? makeStopWatch() : void 0;
@@ -9572,7 +9794,11 @@ function createRoom(options, config) {
         currentItems.set(id, crdt._serialize());
       }
       const ops = getTreesDiffOperations(currentItems, nodes);
-      const result = applyRemoteOps(ops);
+      const result = applyRemoteOps(
+        ops,
+        /* fromSnapshot */
+        true
+      );
       notify(result.updates);
     } else {
       context.root = LiveObject._fromItems(
@@ -9654,15 +9880,16 @@ function createRoom(options, config) {
     );
     return { opsToEmit: opsWithOpIds, reverse, updates };
   }
-  function applyRemoteOps(ops) {
+  function applyRemoteOps(ops, fromSnapshot = false) {
     return applyOps(
       [],
       ops,
       /* isLocal */
-      false
+      false,
+      fromSnapshot
     );
   }
-  function applyOps(pframes, ops, isLocal) {
+  function applyOps(pframes, ops, isLocal, fromSnapshot = false) {
     const output = {
       reverse: new Deque(),
       storageUpdates: /* @__PURE__ */ new Map(),
@@ -9698,7 +9925,7 @@ function createRoom(options, config) {
       } else {
         source = 1 /* THEIRS */;
       }
-      const applyOpResult = applyOp(op, source);
+      const applyOpResult = applyOp(op, source, fromSnapshot);
       if (applyOpResult.modified) {
         const nodeId = applyOpResult.modified.node._id;
         if (!(nodeId && createdNodeIds.has(nodeId))) {
@@ -9724,7 +9951,7 @@ function createRoom(options, config) {
       }
     };
   }
-  function applyOp(op, source) {
+  function applyOp(op, source, fromSnapshot = false) {
     if (isIgnoredOp(op)) {
       return { modified: false };
     }
@@ -9763,7 +9990,7 @@ function createRoom(options, config) {
         if (parentNode === void 0) {
           return { modified: false };
         }
-        return parentNode._attachChild(op, source);
+        return parentNode._attachChild(op, source, fromSnapshot);
       }
     }
   }
@@ -9903,12 +10130,11 @@ function createRoom(options, config) {
     }
   }
   function applyAndSendOfflineOps(unackedOps) {
-    if (unackedOps.size === 0) {
+    if (unackedOps.length === 0) {
       return;
     }
     const messages = [];
-    const inOps = Array.from(unackedOps.values());
-    const result = applyLocalOps(inOps);
+    const result = applyLocalOps(unackedOps);
     messages.push({
       type: ClientMsgCode.UPDATE_STORAGE,
       ops: result.opsToEmit
@@ -10132,7 +10358,7 @@ function createRoom(options, config) {
     const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
       for (const op of storageOps) {
-        context.unacknowledgedOps.set(op.opId, op);
+        context.unacknowledgedOps.add(op);
       }
       notifyStorageStatus();
     }
@@ -10359,9 +10585,9 @@ function createRoom(options, config) {
     }
   }
   function processInitialStorage(nodes) {
-    const unacknowledgedOps = new Map(context.unacknowledgedOps);
+    const unacknowledgedOps2 = [...context.unacknowledgedOps.values()];
     createOrUpdateRootFromMessage(nodes);
-    applyAndSendOfflineOps(unacknowledgedOps);
+    applyAndSendOfflineOps(unacknowledgedOps2);
     _resolveStoragePromise?.();
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
@@ -10950,6 +11176,11 @@ function createRoom(options, config) {
       connect: () => managedSocket.connect(),
       reconnect: () => managedSocket.reconnect(),
       disconnect: () => managedSocket.disconnect(),
+      _dump: () => {
+        const n = context.pool.nodes.size;
+        return `Room "${roomId}" (${n} node${n === 1 ? "" : "s"}):
+${dumpPool(context.pool)}`;
+      },
       destroy: () => {
         pendingFeedsRequests.forEach(
           (request) => request.reject(new Error("Room destroyed"))
@@ -11457,6 +11688,7 @@ function createClient(options) {
     {
       enterRoom,
       getRoom,
+      _dump: () => Array.from(roomsById.values(), ({ room }) => room._dump()).join("\n\n"),
       logout,
       // Public inbox notifications API
       getInboxNotifications: httpClient.getInboxNotifications,