@liveblocks/react 1.10.0-beta3 → 1.10.0

package/dist/index.js

@@ -5,7 +5,7 @@ var _core = require('@liveblocks/core');
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "1.10.0-beta3";
+var PKG_VERSION = "1.10.0";
 var PKG_FORMAT = "cjs";
 
 // src/ClientSideSuspense.tsx
@@ -63,6 +63,10 @@ var _client = require('@liveblocks/client');
 
 
 
+
+
+
+
 
 // src/comments/errors.ts
 var CreateThreadError = class extends Error {
@@ -187,34 +191,6 @@ function selectedThreads(roomId, state, options) {
   return threads.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
 }
 
-// src/comments/lib/upsert-comment.ts
-function upsertComment(threads, newComment) {
-  const thread = threads[newComment.threadId];
-  if (thread === void 0) {
-    return threads;
-  }
-  const newComments = [];
-  let updated = false;
-  for (const comment of thread.comments) {
-    if (comment.id === newComment.id) {
-      updated = true;
-      newComments.push(newComment);
-    } else {
-      newComments.push(comment);
-    }
-  }
-  if (!updated) {
-    newComments.push(newComment);
-  }
-  return {
-    ...threads,
-    [thread.id]: {
-      ...thread,
-      comments: newComments
-    }
-  };
-}
-
 // src/lib/use-initial.ts
 
 function useInitial(value) {
@@ -383,7 +359,9 @@ function createRoomContext(client, options) {
     );
     React2.useEffect(() => {
       async function handleCommentEvent(message) {
-        const info = await room.getThread({ threadId: message.threadId });
+        const info = await room[_core.kInternal].comments.getThread({
+          threadId: message.threadId
+        });
         if (!info) {
           store.deleteThread(message.threadId);
           return;
@@ -411,6 +389,9 @@ function createRoomContext(client, options) {
         (message) => void handleCommentEvent(message)
       );
     }, [room]);
+    React2.useEffect(() => {
+      void getThreadsUpdates(room.id);
+    }, [room.id]);
     React2.useEffect(() => {
       const pair = stableEnterRoom(roomId, frozenProps);
       setRoomLeavePair(pair);
@@ -803,7 +784,7 @@ function createRoomContext(client, options) {
       );
       if (requestsCache.has(notificationSettingsQuery)) {
         requests.push(
-          room.getRoomNotificationSettings().then((settings) => {
+          room[_core.kInternal].notifications.getRoomNotificationSettings().then((settings) => {
             store.updateRoomInboxNotificationSettings(
               room.id,
               settings,
@@ -813,11 +794,11 @@ function createRoomContext(client, options) {
           })
         );
       }
-      const lastRequestedAt = room[_core.kInternal].comments.lastRequestedAt;
-      if (lastRequestedAt === null)
+      const lastRequestedAt = lastRequestedAtByRoom.get(room.id);
+      if (lastRequestedAt === void 0)
         return;
       requests.push(
-        room.getThreads({ since: lastRequestedAt }).then((result) => {
+        room[_core.kInternal].comments.getThreads({ since: lastRequestedAt }).then((result) => {
           store.updateThreadsAndNotifications(
             result.threads,
             result.inboxNotifications,
@@ -827,7 +808,7 @@ function createRoomContext(client, options) {
           const room2 = client.getRoom(roomId);
           if (room2 === null)
             return;
-          room2[_core.kInternal].comments.lastRequestedAt = result.meta.requestedAt;
+          lastRequestedAtByRoom.set(room2.id, result.meta.requestedAt);
         }).catch(() => {
         })
       );
@@ -867,7 +848,7 @@ function createRoomContext(client, options) {
     if (requestInfo !== void 0) {
       return requestInfo.promise;
     }
-    const promise = room.getThreads(options2);
+    const promise = room[_core.kInternal].comments.getThreads(options2);
     requestsCache.set(queryKey, {
       promise,
       subscribers: 0
@@ -884,9 +865,9 @@ function createRoomContext(client, options) {
         result.deletedInboxNotifications,
         queryKey
       );
-      const lastRequestedAt = room[_core.kInternal].comments.lastRequestedAt;
-      if (lastRequestedAt === null || lastRequestedAt > result.meta.requestedAt) {
-        room[_core.kInternal].comments.lastRequestedAt = result.meta.requestedAt;
+      const lastRequestedAt = lastRequestedAtByRoom.get(room.id);
+      if (lastRequestedAt === void 0 || lastRequestedAt > result.meta.requestedAt) {
+        lastRequestedAtByRoom.set(room.id, result.meta.requestedAt);
       }
     } catch (err) {
       store.setQueryState(queryKey, {
@@ -896,6 +877,35 @@ function createRoomContext(client, options) {
     }
     poller.start(POLLING_INTERVAL);
   }
+  const DEFAULT_DEDUPING_INTERVAL = 2e3;
+  const lastRequestedAtByRoom = /* @__PURE__ */ new Map();
+  let isFetchingThreadsUpdates = false;
+  async function getThreadsUpdates(roomId) {
+    const room = client.getRoom(roomId);
+    if (room === null)
+      return;
+    const since = lastRequestedAtByRoom.get(room.id);
+    if (since === void 0)
+      return;
+    if (isFetchingThreadsUpdates)
+      return;
+    try {
+      isFetchingThreadsUpdates = true;
+      const updates = await room[_core.kInternal].comments.getThreads({ since });
+      setTimeout(() => {
+        isFetchingThreadsUpdates = false;
+      }, DEFAULT_DEDUPING_INTERVAL);
+      store.updateThreadsAndNotifications(
+        updates.threads,
+        updates.inboxNotifications,
+        updates.deletedThreads,
+        updates.deletedInboxNotifications
+      );
+      lastRequestedAtByRoom.set(room.id, updates.meta.requestedAt);
+    } catch (err) {
+      isFetchingThreadsUpdates = false;
+    }
+  }
   function useThreads(options2 = { query: { metadata: {} } }) {
     const room = useRoom();
     const queryKey = React2.useMemo(
@@ -975,12 +985,12 @@ function createRoomContext(client, options) {
         const metadata = "metadata" in options2 ? options2.metadata : {};
         const threadId = createThreadId();
         const commentId = createCommentId();
-        const now = /* @__PURE__ */ new Date();
+        const createdAt = /* @__PURE__ */ new Date();
         const newComment = {
           id: commentId,
           threadId,
           roomId: room.id,
-          createdAt: now,
+          createdAt,
           type: "comment",
           userId: getCurrentUserId(room),
           body,
@@ -989,7 +999,8 @@ function createRoomContext(client, options) {
         const newThread = {
           id: threadId,
           type: "thread",
-          createdAt: now,
+          createdAt,
+          updatedAt: createdAt,
           roomId: room.id,
           metadata,
           comments: [newComment]
@@ -1000,7 +1011,7 @@ function createRoomContext(client, options) {
           thread: newThread,
           id: optimisticUpdateId
         });
-        room.createThread({ threadId, commentId, body, metadata }).then(
+        room[_core.kInternal].comments.createThread({ threadId, commentId, body, metadata }).then(
           (thread) => {
             store.set((state) => ({
               ...state,
@@ -1039,23 +1050,38 @@ function createRoomContext(client, options) {
         }
         const threadId = options2.threadId;
         const metadata = options2.metadata;
+        const updatedAt = /* @__PURE__ */ new Date();
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
         store.pushOptimisticUpdate({
           type: "edit-thread-metadata",
           metadata,
           id: optimisticUpdateId,
-          threadId
+          threadId,
+          updatedAt
         });
-        room.editThreadMetadata({ metadata, threadId }).then(
+        room[_core.kInternal].comments.editThreadMetadata({ metadata, threadId }).then(
           (metadata2) => {
             store.set((state) => {
               const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              );
               if (existingThread === void 0) {
                 return {
                   ...state,
-                  optimisticUpdates: state.optimisticUpdates.filter(
-                    (update) => update.id !== optimisticUpdateId
-                  )
+                  optimisticUpdates: updatedOptimisticUpdates
+                };
+              }
+              if (existingThread.deletedAt !== void 0) {
+                return {
+                  ...state,
+                  optimisticUpdates: updatedOptimisticUpdates
+                };
+              }
+              if (existingThread.updatedAt && existingThread.updatedAt > updatedAt) {
+                return {
+                  ...state,
+                  optimisticUpdates: updatedOptimisticUpdates
                 };
               }
               return {
@@ -1070,9 +1096,7 @@ function createRoomContext(client, options) {
                     }
                   }
                 },
-                optimisticUpdates: state.optimisticUpdates.filter(
-                  (update) => update.id !== optimisticUpdateId
-                )
+                optimisticUpdates: updatedOptimisticUpdates
               };
             });
           },
@@ -1094,64 +1118,44 @@ function createRoomContext(client, options) {
     const room = useRoom();
     return React2.useCallback(
       ({ threadId, commentId, emoji }) => {
-        const now = /* @__PURE__ */ new Date();
+        const createdAt = /* @__PURE__ */ new Date();
         const userId = getCurrentUserId(room);
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
         store.pushOptimisticUpdate({
           type: "add-reaction",
           threadId,
           commentId,
-          emoji,
-          userId,
-          createdAt: now,
+          reaction: {
+            emoji,
+            userId,
+            createdAt
+          },
           id: optimisticUpdateId
         });
-        room.addReaction({ threadId, commentId, emoji }).then(
+        room[_core.kInternal].comments.addReaction({ threadId, commentId, emoji }).then(
           (addedReaction) => {
             store.set((state) => {
               const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              );
               if (existingThread === void 0) {
                 return {
                   ...state,
-                  optimisticUpdates: state.optimisticUpdates.filter(
-                    (update) => update.id !== optimisticUpdateId
-                  )
+                  optimisticUpdates: updatedOptimisticUpdates
                 };
               }
               return {
                 ...state,
                 threads: {
                   ...state.threads,
-                  [threadId]: {
-                    ...existingThread,
-                    comments: existingThread.comments.map(
-                      (comment) => comment.id === commentId ? {
-                        ...comment,
-                        reactions: comment.reactions.some(
-                          (reaction) => reaction.emoji === addedReaction.emoji
-                        ) ? comment.reactions.map(
-                          (reaction) => reaction.emoji === addedReaction.emoji ? {
-                            ...reaction,
-                            users: [
-                              ...reaction.users,
-                              { id: addedReaction.userId }
-                            ]
-                          } : reaction
-                        ) : [
-                          ...comment.reactions,
-                          {
-                            emoji: addedReaction.emoji,
-                            createdAt: addedReaction.createdAt,
-                            users: [{ id: addedReaction.userId }]
-                          }
-                        ]
-                      } : comment
-                    )
-                  }
+                  [threadId]: _core.addReaction.call(void 0, 
+                    existingThread,
+                    commentId,
+                    addedReaction
+                  )
                 },
-                optimisticUpdates: state.optimisticUpdates.filter(
-                  (update) => update.id !== optimisticUpdateId
-                )
+                optimisticUpdates: updatedOptimisticUpdates
               };
             });
           },
@@ -1175,6 +1179,7 @@ function createRoomContext(client, options) {
     return React2.useCallback(
       ({ threadId, commentId, emoji }) => {
         const userId = getCurrentUserId(room);
+        const removedAt = /* @__PURE__ */ new Date();
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
         store.pushOptimisticUpdate({
           type: "remove-reaction",
@@ -1182,67 +1187,35 @@ function createRoomContext(client, options) {
           commentId,
           emoji,
           userId,
+          removedAt,
           id: optimisticUpdateId
         });
-        room.removeReaction({ threadId, commentId, emoji }).then(
+        room[_core.kInternal].comments.removeReaction({ threadId, commentId, emoji }).then(
           () => {
             store.set((state) => {
               const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              );
               if (existingThread === void 0) {
                 return {
                   ...state,
-                  optimisticUpdates: state.optimisticUpdates.filter(
-                    (update) => update.id !== optimisticUpdateId
-                  )
+                  optimisticUpdates: updatedOptimisticUpdates
                 };
               }
               return {
                 ...state,
                 threads: {
                   ...state.threads,
-                  [threadId]: {
-                    ...existingThread,
-                    comments: existingThread.comments.map((comment) => {
-                      if (comment.id !== commentId) {
-                        return comment;
-                      }
-                      const existingReaction = comment.reactions.find(
-                        (reaction) => reaction.emoji === emoji
-                      );
-                      if (existingReaction === void 0) {
-                        return comment;
-                      }
-                      const reactions = comment.reactions;
-                      if (!existingReaction.users.some(
-                        (user) => user.id === userId
-                      )) {
-                        return comment;
-                      }
-                      if (existingReaction.users.length <= 1) {
-                        return {
-                          ...comment,
-                          reactions: reactions.filter(
-                            (reaction) => reaction.emoji !== emoji
-                          )
-                        };
-                      }
-                      return {
-                        ...comment,
-                        reactions: reactions.map(
-                          (reaction) => reaction.emoji !== emoji ? reaction : {
-                            ...reaction,
-                            users: reaction.users.filter(
-                              (user) => user.id !== userId
-                            )
-                          }
-                        )
-                      };
-                    })
-                  }
+                  [threadId]: _core.removeReaction.call(void 0, 
+                    existingThread,
+                    commentId,
+                    emoji,
+                    userId,
+                    removedAt
+                  )
                 },
-                optimisticUpdates: state.optimisticUpdates.filter(
-                  (update) => update.id !== optimisticUpdateId
-                )
+                optimisticUpdates: updatedOptimisticUpdates
               };
             });
           },
@@ -1266,44 +1239,58 @@ function createRoomContext(client, options) {
     return React2.useCallback(
       ({ threadId, body }) => {
         const commentId = createCommentId();
-        const now = /* @__PURE__ */ new Date();
+        const createdAt = /* @__PURE__ */ new Date();
         const comment = {
           id: commentId,
           threadId,
           roomId: room.id,
           type: "comment",
-          createdAt: now,
+          createdAt,
           userId: getCurrentUserId(room),
           body,
           reactions: []
         };
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
-        const inboxNotification = Object.values(
-          store.get().inboxNotifications
-        ).find((inboxNotification2) => inboxNotification2.threadId === threadId);
         store.pushOptimisticUpdate({
           type: "create-comment",
           comment,
-          id: optimisticUpdateId,
-          inboxNotificationId: _optionalChain([inboxNotification, 'optionalAccess', _6 => _6.id])
+          id: optimisticUpdateId
         });
-        room.createComment({ threadId, commentId, body }).then(
+        room[_core.kInternal].comments.createComment({ threadId, commentId, body }).then(
           (newComment) => {
-            store.set((state) => ({
-              ...state,
-              threads: upsertComment(state.threads, newComment),
-              inboxNotifications: inboxNotification ? {
+            store.set((state) => {
+              const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              );
+              if (existingThread === void 0) {
+                return {
+                  ...state,
+                  optimisticUpdates: updatedOptimisticUpdates
+                };
+              }
+              const inboxNotification = Object.values(
+                state.inboxNotifications
+              ).find((notification) => notification.threadId === threadId);
+              const updatedInboxNotifications = inboxNotification !== void 0 ? {
                 ...state.inboxNotifications,
                 [inboxNotification.id]: {
                   ...inboxNotification,
                   notifiedAt: newComment.createdAt,
                   readAt: newComment.createdAt
                 }
-              } : state.inboxNotifications,
-              optimisticUpdates: state.optimisticUpdates.filter(
-                (update) => update.id !== optimisticUpdateId
-              )
-            }));
+              } : state.inboxNotifications;
+              return {
+                ...state,
+                threads: {
+                  ...state.threads,
+                  [threadId]: _core.upsertComment.call(void 0, existingThread, newComment)
+                  // Upsert the new comment into the thread comments list (if applicable)
+                },
+                inboxNotifications: updatedInboxNotifications,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            });
           },
           (err) => onMutationFailure(
             err,
@@ -1325,25 +1312,56 @@ function createRoomContext(client, options) {
     const room = useRoom();
     return React2.useCallback(
       ({ threadId, commentId, body }) => {
-        const now = /* @__PURE__ */ new Date();
+        const editedAt = /* @__PURE__ */ new Date();
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
+        const thread = store.get().threads[threadId];
+        if (thread === void 0) {
+          _core.console.warn(
+            `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
+          );
+          return;
+        }
+        const comment = thread.comments.find(
+          (comment2) => comment2.id === commentId
+        );
+        if (comment === void 0 || comment.deletedAt !== void 0) {
+          _core.console.warn(
+            `Internal unexpected behavior. Cannot edit comment "${commentId}" in thread "${threadId}" because the comment does not exist in the cache.`
+          );
+          return;
+        }
         store.pushOptimisticUpdate({
           type: "edit-comment",
-          threadId,
-          commentId,
-          body,
-          editedAt: now,
+          comment: {
+            ...comment,
+            editedAt,
+            body
+          },
           id: optimisticUpdateId
         });
-        room.editComment({ threadId, commentId, body }).then(
+        room[_core.kInternal].comments.editComment({ threadId, commentId, body }).then(
           (editedComment) => {
-            store.set((state) => ({
-              ...state,
-              threads: upsertComment(state.threads, editedComment),
-              optimisticUpdates: state.optimisticUpdates.filter(
+            store.set((state) => {
+              const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
                 (update) => update.id !== optimisticUpdateId
-              )
-            }));
+              );
+              if (existingThread === void 0) {
+                return {
+                  ...state,
+                  optimisticUpdates: updatedOptimisticUpdates
+                };
+              }
+              return {
+                ...state,
+                threads: {
+                  ...state.threads,
+                  [threadId]: _core.upsertComment.call(void 0, existingThread, editedComment)
+                  // Upsert the edited comment into the thread comments list (if applicable)
+                },
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            });
           },
           (err) => onMutationFailure(
             err,
@@ -1364,49 +1382,39 @@ function createRoomContext(client, options) {
     const room = useRoom();
     return React2.useCallback(
       ({ threadId, commentId }) => {
-        const now = /* @__PURE__ */ new Date();
+        const deletedAt = /* @__PURE__ */ new Date();
         const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
         store.pushOptimisticUpdate({
           type: "delete-comment",
           threadId,
           commentId,
-          deletedAt: now,
+          deletedAt,
           id: optimisticUpdateId
         });
-        room.deleteComment({ threadId, commentId }).then(
+        room[_core.kInternal].comments.deleteComment({ threadId, commentId }).then(
           () => {
             store.set((state) => {
               const existingThread = state.threads[threadId];
+              const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              );
               if (existingThread === void 0) {
                 return {
                   ...state,
-                  optimisticUpdates: state.optimisticUpdates.filter(
-                    (update) => update.id !== optimisticUpdateId
-                  )
+                  optimisticUpdates: updatedOptimisticUpdates
                 };
               }
-              const newThread = {
-                ...existingThread,
-                comments: existingThread.comments.map(
-                  (comment) => comment.id === commentId ? {
-                    ...comment,
-                    deletedAt: now,
-                    body: void 0
-                  } : comment
-                )
-              };
-              const newThreads = { ...state.threads, [threadId]: newThread };
-              if (!newThread.comments.some(
-                (comment) => comment.deletedAt === void 0
-              )) {
-                delete newThreads[threadId];
-              }
               return {
                 ...state,
-                threads: newThreads,
-                optimisticUpdates: state.optimisticUpdates.filter(
-                  (update) => update.id !== optimisticUpdateId
-                )
+                threads: {
+                  ...state.threads,
+                  [threadId]: _core.deleteComment.call(void 0, 
+                    existingThread,
+                    commentId,
+                    deletedAt
+                  )
+                },
+                optimisticUpdates: updatedOptimisticUpdates
               };
             });
           },
@@ -1454,7 +1462,7 @@ function createRoomContext(client, options) {
             );
           }
         } catch (error) {
-          _core.console.error(_optionalChain([error, 'optionalAccess', _7 => _7.message]));
+          _core.console.error(_optionalChain([error, 'optionalAccess', _6 => _6.message]));
         }
       };
       if (mentionSuggestionsCache.has(mentionSuggestionsCacheKey)) {
@@ -1502,48 +1510,52 @@ function createRoomContext(client, options) {
     );
   }
   function useMarkThreadAsRead() {
-    return React2.useCallback((threadId) => {
-      const inboxNotification = Object.values(
-        store.get().inboxNotifications
-      ).find((inboxNotification2) => inboxNotification2.threadId === threadId);
-      if (!inboxNotification)
-        return;
-      const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
-      const now = /* @__PURE__ */ new Date();
-      store.pushOptimisticUpdate({
-        type: "mark-inbox-notification-as-read",
-        id: optimisticUpdateId,
-        inboxNotificationId: inboxNotification.id,
-        readAt: now
-      });
-      client.markInboxNotificationAsRead(inboxNotification.id).then(
-        () => {
-          store.set((state) => ({
-            ...state,
-            inboxNotifications: {
-              ...state.inboxNotifications,
-              [inboxNotification.id]: {
-                ...inboxNotification,
-                readAt: now
-              }
-            },
-            optimisticUpdates: state.optimisticUpdates.filter(
-              (update) => update.id !== optimisticUpdateId
-            )
-          }));
-        },
-        (err) => {
-          onMutationFailure(
-            err,
-            optimisticUpdateId,
-            (error) => new MarkInboxNotificationAsReadError(error, {
-              inboxNotificationId: inboxNotification.id
-            })
-          );
+    const room = useRoom();
+    return React2.useCallback(
+      (threadId) => {
+        const inboxNotification = Object.values(
+          store.get().inboxNotifications
+        ).find((inboxNotification2) => inboxNotification2.threadId === threadId);
+        if (!inboxNotification)
           return;
-        }
-      );
-    }, []);
+        const optimisticUpdateId = _nanoid.nanoid.call(void 0, );
+        const now = /* @__PURE__ */ new Date();
+        store.pushOptimisticUpdate({
+          type: "mark-inbox-notification-as-read",
+          id: optimisticUpdateId,
+          inboxNotificationId: inboxNotification.id,
+          readAt: now
+        });
+        room[_core.kInternal].notifications.markInboxNotificationAsRead(inboxNotification.id).then(
+          () => {
+            store.set((state) => ({
+              ...state,
+              inboxNotifications: {
+                ...state.inboxNotifications,
+                [inboxNotification.id]: {
+                  ...inboxNotification,
+                  readAt: now
+                }
+              },
+              optimisticUpdates: state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              )
+            }));
+          },
+          (err) => {
+            onMutationFailure(
+              err,
+              optimisticUpdateId,
+              (error) => new MarkInboxNotificationAsReadError(error, {
+                inboxNotificationId: inboxNotification.id
+              })
+            );
+            return;
+          }
+        );
+      },
+      [room]
+    );
   }
   function makeNotificationSettingsQueryKey(roomId) {
     return `${roomId}:NOTIFICATION_SETTINGS`;
@@ -1553,7 +1565,7 @@ function createRoomContext(client, options) {
     if (requestInfo !== void 0) {
       return requestInfo.promise;
     }
-    const promise = room.getRoomNotificationSettings();
+    const promise = room[_core.kInternal].notifications.getRoomNotificationSettings();
     requestsCache.set(queryKey, {
       promise,
       subscribers: 0
@@ -1653,7 +1665,7 @@ function createRoomContext(client, options) {
           roomId: room.id,
           settings
         });
-        room.updateRoomNotificationSettings(settings).then(
+        room[_core.kInternal].notifications.updateRoomNotificationSettings(settings).then(
           (settings2) => {
             store.set((state) => ({
               ...state,
@@ -1787,7 +1799,7 @@ function getCurrentUserId(room) {
 }
 function handleApiError(err) {
   const message = `Request failed with status ${err.status}: ${err.message}`;
-  if (_optionalChain([err, 'access', _8 => _8.details, 'optionalAccess', _9 => _9.error]) === "FORBIDDEN") {
+  if (_optionalChain([err, 'access', _7 => _7.details, 'optionalAccess', _8 => _8.error]) === "FORBIDDEN") {
     const detailedMessage = [message, err.details.suggestion, err.details.docs].filter(Boolean).join("\n");
     _core.console.error(detailedMessage);
   }
@@ -1851,7 +1863,7 @@ function createSharedContext(client) {
     );
     return {
       ...state,
-      user: _optionalChain([state, 'optionalAccess', _10 => _10.data])
+      user: _optionalChain([state, 'optionalAccess', _9 => _9.data])
     };
   }
   function useRoomInfo(roomId) {
@@ -1891,7 +1903,7 @@ function createSharedContext(client) {
     );
     return {
       ...state,
-      info: _optionalChain([state, 'optionalAccess', _11 => _11.data])
+      info: _optionalChain([state, 'optionalAccess', _10 => _10.data])
     };
   }
   const bundle = {
@@ -1919,6 +1931,7 @@ var INBOX_NOTIFICATIONS_QUERY = "INBOX_NOTIFICATIONS";
 function createLiveblocksContext(client) {
   const shared = createSharedContext(client);
   const store = client[_core.kInternal].cacheStore;
+  const notifications = client[_core.kInternal].notifications;
   function LiveblocksProvider(props) {
     return /* @__PURE__ */ React.default.createElement(
       ContextBundle2.Provider,
@@ -1933,7 +1946,7 @@ function createLiveblocksContext(client) {
   let lastRequestedAt;
   const poller = _core.makePoller.call(void 0, refreshThreadsAndNotifications);
   function refreshThreadsAndNotifications() {
-    return client.getInboxNotifications({ since: lastRequestedAt }).then(
+    return notifications.getInboxNotifications({ since: lastRequestedAt }).then(
       (result) => {
         lastRequestedAt = result.meta.requestedAt;
         store.updateThreadsAndNotifications(
@@ -1972,7 +1985,7 @@ function createLiveblocksContext(client) {
       isLoading: true
     });
     try {
-      fetchInboxNotificationsRequest = client.getInboxNotifications();
+      fetchInboxNotificationsRequest = notifications.getInboxNotifications();
       const result = await fetchInboxNotificationsRequest;
       store.updateThreadsAndNotifications(
         result.threads,
@@ -2122,7 +2135,7 @@ function createLiveblocksContext(client) {
         inboxNotificationId,
         readAt
       });
-      client.markInboxNotificationAsRead(inboxNotificationId).then(
+      notifications.markInboxNotificationAsRead(inboxNotificationId).then(
         () => {
           store.set((state) => {
             const existingNotification = state.inboxNotifications[inboxNotificationId];
@@ -2169,7 +2182,7 @@ function createLiveblocksContext(client) {
         id: optimisticUpdateId,
         readAt
       });
-      client.markAllInboxNotificationsAsRead().then(
+      notifications.markAllInboxNotificationsAsRead().then(
         () => {
           store.set((state) => ({
             ...state,