@liveblocks/react 2.7.0 → 2.7.2

package/dist/{chunk-OKR7ROQ5.mjs → chunk-QC6HYSYS.mjs}

@@ -1,6 +1,6 @@
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "2.7.0";
+var PKG_VERSION = "2.7.2";
 var PKG_FORMAT = "esm";
 
 // src/ClientSideSuspense.tsx
@@ -13,123 +13,37 @@ function ClientSideSuspense(props) {
   return /* @__PURE__ */ React.createElement(React.Suspense, { fallback: props.fallback }, mounted ? typeof props.children === "function" ? props.children() : props.children : props.fallback);
 }
 
-// src/comments/errors.ts
-var CreateThreadError = class extends Error {
-  constructor(cause, context) {
-    super("Create thread failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateThreadError";
-  }
-};
-var DeleteThreadError = class extends Error {
-  constructor(cause, context) {
-    super("Delete thread failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "DeleteThreadError";
-  }
-};
-var EditThreadMetadataError = class extends Error {
-  constructor(cause, context) {
-    super("Edit thread metadata failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditThreadMetadataError";
-  }
-};
-var MarkThreadAsResolvedError = class extends Error {
-  constructor(cause, context) {
-    super("Mark thread as resolved failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkThreadAsResolvedError";
-  }
-};
-var MarkThreadAsUnresolvedError = class extends Error {
-  constructor(cause, context) {
-    super("Mark thread as unresolved failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkThreadAsUnresolvedError";
-  }
-};
-var CreateCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Create comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateCommentError";
-  }
-};
-var EditCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Edit comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditCommentError";
-  }
-};
-var DeleteCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Delete comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "DeleteCommentError";
-  }
-};
-var AddReactionError = class extends Error {
-  constructor(cause, context) {
-    super("Add reaction failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "AddReactionError";
-  }
-};
-var RemoveReactionError = class extends Error {
-  constructor(cause, context) {
-    super("Remove reaction failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "RemoveReactionError";
-  }
-};
-var MarkInboxNotificationAsReadError = class extends Error {
-  constructor(cause, context) {
-    super("Mark inbox notification as read failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkInboxNotificationAsReadError";
-  }
-};
-var UpdateNotificationSettingsError = class extends Error {
-  constructor(cause, context) {
-    super("Update notification settings failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "UpdateNotificationSettingsError";
-  }
-};
+// src/contexts.ts
+import * as React2 from "react";
+var RoomContext = React2.createContext(null);
+function useRoomOrNull() {
+  return React2.useContext(RoomContext);
+}
+function useIsInsideRoom() {
+  const room = useRoomOrNull();
+  return room !== null;
+}
 
-// src/room.tsx
-import { shallow as shallow2 } from "@liveblocks/client";
+// src/liveblocks.tsx
 import {
-  CommentsApiError,
-  console as console3,
-  createCommentId,
-  createThreadId,
-  deprecateIf,
-  errorIf,
-  kInternal as kInternal2,
-  makeEventSource,
-  makePoller as makePoller2,
-  nn,
-  NotificationsApiError,
-  ServerMsgCode,
-  stringify as stringify2
+  assert,
+  createClient,
+  kInternal,
+  makePoller,
+  memoizeOnSuccess,
+  raise,
+  shallow as shallow3,
+  stringify
 } from "@liveblocks/core";
-import * as React4 from "react";
-import { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from "use-sync-external-store/shim/with-selector.js";
+import React3, {
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect as useEffect3,
+  useMemo
+} from "react";
+import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
 
 // src/lib/compare.ts
 function byFirstCreated(a, b) {
@@ -204,6 +118,21 @@ async function autoRetry(promiseFn, maxTries, backoff) {
   }
 }
 
+// src/lib/shallow2.ts
+import { isPlainObject as isPlainObject2, shallow } from "@liveblocks/core";
+function shallow2(a, b) {
+  if (!isPlainObject2(a) || !isPlainObject2(b)) {
+    return shallow(a, b);
+  }
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(b, key) && shallow(a[key], b[key])
+  );
+}
+
 // src/lib/use-initial.ts
 import { useCallback, useReducer } from "react";
 
@@ -261,66 +190,147 @@ var use = (
   }
 );
 
-// src/liveblocks.tsx
+// src/umbrella-store.ts
 import {
-  assert,
-  createClient,
-  kInternal,
-  makePoller,
-  memoizeOnSuccess,
-  raise,
-  shallow,
-  stringify
+  compactObject,
+  console as console2,
+  createStore,
+  mapValues,
+  nanoid,
+  nn
 } from "@liveblocks/core";
-import React2, {
-  createContext,
-  useCallback as useCallback2,
-  useContext,
-  useEffect as useEffect3,
-  useMemo
-} from "react";
-import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
-import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
-
-// src/umbrella-store.ts
-import { console as console2, createStore, mapValues, nanoid } from "@liveblocks/core";
+var QUERY_STATE_LOADING = Object.freeze({ isLoading: true });
+var QUERY_STATE_OK = Object.freeze({ isLoading: false, data: void 0 });
+var INBOX_NOTIFICATIONS_QUERY = "INBOX_NOTIFICATIONS";
+function makeNotificationSettingsQueryKey(roomId) {
+  return `${roomId}:NOTIFICATION_SETTINGS`;
+}
+function makeVersionsQueryKey(roomId) {
+  return `${roomId}-VERSIONS`;
+}
 var UmbrellaStore = class {
   constructor() {
+    this._prevState = null;
+    this._stateCached = null;
     this._store = createStore({
-      threads: {},
+      rawThreadsById: {},
       queries: {},
       optimisticUpdates: [],
-      inboxNotifications: {},
-      notificationSettings: {},
-      versions: {}
+      inboxNotificationsById: {},
+      notificationSettingsByRoomId: {},
+      versionsByRoomId: {}
     });
-    this.get = this.get.bind(this);
-    this.subscribe = this.subscribe.bind(this);
+    this.getThreads = this.getThreads.bind(this);
+    this.getInboxNotifications = this.getInboxNotifications.bind(this);
+    this.getInboxNotificationsAsync = this.getInboxNotificationsAsync.bind(this);
+    this.subscribeThreads = this.subscribeThreads.bind(this);
+    this.subscribeInboxNotifications = this.subscribeInboxNotifications.bind(this);
+    this.subscribeNotificationSettings = this.subscribeNotificationSettings.bind(this);
+    this.subscribeVersions = this.subscribeVersions.bind(this);
+    this._hasOptimisticUpdates = this._hasOptimisticUpdates.bind(this);
+    this._subscribeOptimisticUpdates = this._subscribeOptimisticUpdates.bind(this);
   }
   get() {
-    return this._store.get();
+    const rawState = this._store.get();
+    if (this._prevState !== rawState || this._stateCached === null) {
+      this._prevState = rawState;
+      this._stateCached = internalToExternalState(rawState);
+    }
+    return this._stateCached;
+  }
+  getThreads() {
+    return this.get();
+  }
+  getInboxNotifications() {
+    return this.get();
+  }
+  // NOTE: This will read the async result, but WILL NOT start loading at the moment!
+  getInboxNotificationsAsync() {
+    const internalState = this._store.get();
+    const query = internalState.queries[INBOX_NOTIFICATIONS_QUERY];
+    if (query === void 0 || query.isLoading) {
+      return QUERY_STATE_LOADING;
+    }
+    if (query.error !== void 0) {
+      return query;
+    }
+    const inboxNotifications = this.get().inboxNotifications;
+    return { isLoading: false, inboxNotifications };
+  }
+  // NOTE: This will read the async result, but WILL NOT start loading at the moment!
+  getNotificationSettingsAsync(roomId) {
+    const state = this.get();
+    const query = state.queries[makeNotificationSettingsQueryKey(roomId)];
+    if (query === void 0 || query.isLoading) {
+      return QUERY_STATE_LOADING;
+    }
+    if (query.error !== void 0) {
+      return query;
+    }
+    return {
+      isLoading: false,
+      settings: nn(state.notificationSettingsByRoomId[roomId])
+    };
+  }
+  getVersionsAsync(roomId) {
+    const state = this.get();
+    const query = state.queries[makeVersionsQueryKey(roomId)];
+    if (query === void 0 || query.isLoading) {
+      return QUERY_STATE_LOADING;
+    }
+    if (query.error !== void 0) {
+      return query;
+    }
+    return {
+      isLoading: false,
+      versions: nn(state.versionsByRoomId[roomId])
+    };
+  }
+  /**
+   * @private Only used by the E2E test suite.
+   */
+  _hasOptimisticUpdates() {
+    return this._store.get().optimisticUpdates.length > 0;
   }
   subscribe(callback) {
     return this._store.subscribe(callback);
   }
+  /**
+   * @private Only used by the E2E test suite.
+   */
+  _subscribeOptimisticUpdates(callback) {
+    return this.subscribe(callback);
+  }
+  subscribeThreads(callback) {
+    return this.subscribe(callback);
+  }
+  subscribeInboxNotifications(callback) {
+    return this.subscribe(callback);
+  }
+  subscribeNotificationSettings(callback) {
+    return this.subscribe(callback);
+  }
+  subscribeVersions(callback) {
+    return this.subscribe(callback);
+  }
   // Direct low-level cache mutations ------------------------------------------------- {{{
   updateThreadsCache(mapFn) {
     this._store.set((state) => {
-      const threads = mapFn(state.threads);
-      return threads !== state.threads ? { ...state, threads } : state;
+      const threads = mapFn(state.rawThreadsById);
+      return threads !== state.rawThreadsById ? { ...state, rawThreadsById: threads } : state;
     });
   }
   updateInboxNotificationsCache(mapFn) {
     this._store.set((state) => {
-      const inboxNotifications = mapFn(state.inboxNotifications);
-      return inboxNotifications !== state.inboxNotifications ? { ...state, inboxNotifications } : state;
+      const inboxNotifications = mapFn(state.inboxNotificationsById);
+      return inboxNotifications !== state.inboxNotificationsById ? { ...state, inboxNotificationsById: inboxNotifications } : state;
     });
   }
   setNotificationSettings(roomId, settings) {
     this._store.set((state) => ({
       ...state,
-      notificationSettings: {
-        ...state.notificationSettings,
+      notificationSettingsByRoomId: {
+        ...state.notificationSettingsByRoomId,
         [roomId]: settings
       }
     }));
@@ -328,8 +338,8 @@ var UmbrellaStore = class {
   setVersions(roomId, versions) {
     this._store.set((state) => ({
       ...state,
-      versions: {
-        ...state.versions,
+      versionsByRoomId: {
+        ...state.versionsByRoomId,
         [roomId]: versions
       }
     }));
@@ -449,6 +459,30 @@ var UmbrellaStore = class {
       });
     });
   }
+  patchThread(threadId, optimisticUpdateId, patch, updatedAt) {
+    return this.updateThread(
+      threadId,
+      optimisticUpdateId,
+      (thread) => ({ ...thread, ...compactObject(patch) }),
+      updatedAt
+    );
+  }
+  addReaction(threadId, optimisticUpdateId, commentId, reaction, createdAt) {
+    this.updateThread(
+      threadId,
+      optimisticUpdateId,
+      (thread) => applyAddReaction(thread, commentId, reaction),
+      createdAt
+    );
+  }
+  removeReaction(threadId, optimisticUpdateId, commentId, emoji, userId, removedAt) {
+    this.updateThread(
+      threadId,
+      optimisticUpdateId,
+      (thread) => applyRemoveReaction(thread, commentId, emoji, userId, removedAt),
+      removedAt
+    );
+  }
   /**
    * Soft-deletes an existing thread by setting its `deletedAt` value,
    * replacing the corresponding optimistic update.
@@ -472,13 +506,13 @@ var UmbrellaStore = class {
   createComment(newComment, optimisticUpdateId) {
     this._store.batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      const existingThread = this._store.get().threads[newComment.threadId];
+      const existingThread = this._store.get().rawThreadsById[newComment.threadId];
       if (!existingThread) {
         return;
       }
       this.updateThreadsCache((cache) => ({
         ...cache,
-        [newComment.threadId]: upsertComment(existingThread, newComment)
+        [newComment.threadId]: applyUpsertComment(existingThread, newComment)
       }));
       this.updateInboxNotificationsCache((cache) => {
         const existingNotification = Object.values(cache).find(
@@ -498,6 +532,21 @@ var UmbrellaStore = class {
       });
     });
   }
+  editComment(threadId, optimisticUpdateId, editedComment) {
+    return this.updateThread(
+      threadId,
+      optimisticUpdateId,
+      (thread) => applyUpsertComment(thread, editedComment)
+    );
+  }
+  deleteComment(threadId, optimisticUpdateId, commentId, deletedAt) {
+    return this.updateThread(
+      threadId,
+      optimisticUpdateId,
+      (thread) => applyDeleteComment(thread, commentId, deletedAt),
+      deletedAt
+    );
+  }
   updateThreadAndNotification(thread, inboxNotification) {
     this._store.batch(() => {
       this.updateThreadsCache((cache) => {
@@ -570,35 +619,29 @@ var UmbrellaStore = class {
   // Query State APIs
   //
   setQueryLoading(queryKey) {
-    this.setQueryState(queryKey, { isLoading: true });
+    this.setQueryState(queryKey, QUERY_STATE_LOADING);
   }
   setQueryOK(queryKey) {
-    this.setQueryState(queryKey, { isLoading: false, data: void 0 });
+    this.setQueryState(queryKey, QUERY_STATE_OK);
   }
   setQueryError(queryKey, error) {
     this.setQueryState(queryKey, { isLoading: false, error });
   }
 };
-function applyOptimisticUpdates(state) {
-  const result = {
-    threads: {
-      ...state.threads
-    },
-    inboxNotifications: {
-      ...state.inboxNotifications
-    },
-    notificationSettings: {
-      ...state.notificationSettings
-    }
+function internalToExternalState(state) {
+  const computed = {
+    threadsById: { ...state.rawThreadsById },
+    inboxNotificationsById: { ...state.inboxNotificationsById },
+    notificationSettingsByRoomId: { ...state.notificationSettingsByRoomId }
   };
   for (const optimisticUpdate of state.optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "create-thread": {
-        result.threads[optimisticUpdate.thread.id] = optimisticUpdate.thread;
+        computed.threadsById[optimisticUpdate.thread.id] = optimisticUpdate.thread;
         break;
       }
       case "edit-thread-metadata": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
@@ -608,7 +651,7 @@ function applyOptimisticUpdates(state) {
         if (thread.updatedAt !== void 0 && thread.updatedAt > optimisticUpdate.updatedAt) {
           break;
         }
-        result.threads[thread.id] = {
+        computed.threadsById[thread.id] = {
           ...thread,
           updatedAt: optimisticUpdate.updatedAt,
           metadata: {
@@ -619,49 +662,51 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "mark-thread-as-resolved": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
         if (thread.deletedAt !== void 0) {
           break;
         }
-        result.threads[thread.id] = {
+        computed.threadsById[thread.id] = {
           ...thread,
           resolved: true
         };
         break;
       }
       case "mark-thread-as-unresolved": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
         if (thread.deletedAt !== void 0) {
           break;
         }
-        result.threads[thread.id] = {
+        computed.threadsById[thread.id] = {
           ...thread,
           resolved: false
         };
         break;
       }
       case "create-comment": {
-        const thread = result.threads[optimisticUpdate.comment.threadId];
+        const thread = computed.threadsById[optimisticUpdate.comment.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[thread.id] = upsertComment(
+        computed.threadsById[thread.id] = applyUpsertComment(
           thread,
           optimisticUpdate.comment
         );
-        const inboxNotification = Object.values(result.inboxNotifications).find(
+        const inboxNotification = Object.values(
+          computed.inboxNotificationsById
+        ).find(
           (notification) => notification.kind === "thread" && notification.threadId === thread.id
         );
         if (inboxNotification === void 0) {
           break;
         }
-        result.inboxNotifications[inboxNotification.id] = {
+        computed.inboxNotificationsById[inboxNotification.id] = {
           ...inboxNotification,
           notifiedAt: optimisticUpdate.comment.createdAt,
           readAt: optimisticUpdate.comment.createdAt
@@ -669,22 +714,22 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "edit-comment": {
-        const thread = result.threads[optimisticUpdate.comment.threadId];
+        const thread = computed.threadsById[optimisticUpdate.comment.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[thread.id] = upsertComment(
+        computed.threadsById[thread.id] = applyUpsertComment(
           thread,
           optimisticUpdate.comment
         );
         break;
       }
       case "delete-comment": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[thread.id] = deleteComment(
+        computed.threadsById[thread.id] = applyDeleteComment(
           thread,
           optimisticUpdate.commentId,
           optimisticUpdate.deletedAt
@@ -692,12 +737,12 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "delete-thread": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[optimisticUpdate.threadId] = {
-          ...result.threads[optimisticUpdate.threadId],
+        computed.threadsById[optimisticUpdate.threadId] = {
+          ...thread,
           deletedAt: optimisticUpdate.deletedAt,
           updatedAt: optimisticUpdate.deletedAt,
           comments: []
@@ -705,11 +750,11 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "add-reaction": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[thread.id] = addReaction(
+        computed.threadsById[thread.id] = applyAddReaction(
           thread,
           optimisticUpdate.commentId,
           optimisticUpdate.reaction
@@ -717,11 +762,11 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "remove-reaction": {
-        const thread = result.threads[optimisticUpdate.threadId];
+        const thread = computed.threadsById[optimisticUpdate.threadId];
         if (thread === void 0) {
           break;
         }
-        result.threads[thread.id] = removeReaction(
+        computed.threadsById[thread.id] = applyRemoveReaction(
           thread,
           optimisticUpdate.commentId,
           optimisticUpdate.emoji,
@@ -731,42 +776,70 @@ function applyOptimisticUpdates(state) {
         break;
       }
       case "mark-inbox-notification-as-read": {
-        result.inboxNotifications[optimisticUpdate.inboxNotificationId] = {
-          ...state.inboxNotifications[optimisticUpdate.inboxNotificationId],
-          readAt: optimisticUpdate.readAt
-        };
+        const ibn = computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId];
+        if (ibn === void 0) {
+          break;
+        }
+        computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId] = { ...ibn, readAt: optimisticUpdate.readAt };
         break;
       }
       case "mark-all-inbox-notifications-as-read": {
-        for (const id in result.inboxNotifications) {
-          result.inboxNotifications[id] = {
-            ...result.inboxNotifications[id],
+        for (const id in computed.inboxNotificationsById) {
+          const ibn = computed.inboxNotificationsById[id];
+          if (ibn === void 0) {
+            break;
+          }
+          computed.inboxNotificationsById[id] = {
+            ...ibn,
             readAt: optimisticUpdate.readAt
           };
         }
         break;
       }
       case "delete-inbox-notification": {
-        const {
-          [optimisticUpdate.inboxNotificationId]: _,
-          ...inboxNotifications
-        } = result.inboxNotifications;
-        result.inboxNotifications = inboxNotifications;
+        delete computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId];
         break;
       }
       case "delete-all-inbox-notifications": {
-        result.inboxNotifications = {};
+        computed.inboxNotificationsById = {};
         break;
       }
       case "update-notification-settings": {
-        result.notificationSettings[optimisticUpdate.roomId] = {
-          ...result.notificationSettings[optimisticUpdate.roomId],
+        const settings = computed.notificationSettingsByRoomId[optimisticUpdate.roomId];
+        if (settings === void 0) {
+          break;
+        }
+        computed.notificationSettingsByRoomId[optimisticUpdate.roomId] = {
+          ...settings,
           ...optimisticUpdate.settings
         };
       }
     }
   }
-  return result;
+  const cleanedThreads = (
+    // Don't expose any soft-deleted threads
+    Object.values(computed.threadsById).filter((thread) => !thread.deletedAt).filter(
+      (thread) => (
+        // Only keep a thread if there is at least one non-deleted comment
+        thread.comments.some((c) => c.deletedAt === void 0)
+      )
+    )
+  );
+  const cleanedNotifications = (
+    // Sort so that the most recent notifications are first
+    Object.values(computed.inboxNotificationsById).filter(
+      (ibn) => ibn.kind === "thread" ? computed.threadsById[ibn.threadId] && computed.threadsById[ibn.threadId]?.deletedAt === void 0 : true
+    ).sort((a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime())
+  );
+  return {
+    inboxNotifications: cleanedNotifications,
+    inboxNotificationsById: computed.inboxNotificationsById,
+    notificationSettingsByRoomId: computed.notificationSettingsByRoomId,
+    queries: state.queries,
+    threads: cleanedThreads,
+    threadsById: computed.threadsById,
+    versionsByRoomId: state.versionsByRoomId
+  };
 }
 function applyThreadUpdates(existingThreads, updates) {
   const updatedThreads = { ...existingThreads };
@@ -819,7 +892,7 @@ function compareInboxNotifications(inboxNotificationA, inboxNotificationB) {
   }
   return 0;
 }
-function upsertComment(thread, comment) {
+function applyUpsertComment(thread, comment) {
   if (thread.deletedAt !== void 0) {
     return thread;
   }
@@ -864,7 +937,7 @@ function upsertComment(thread, comment) {
   }
   return thread;
 }
-function deleteComment(thread, commentId, deletedAt) {
+function applyDeleteComment(thread, commentId, deletedAt) {
   if (thread.deletedAt !== void 0) {
     return thread;
   }
@@ -884,12 +957,11 @@ function deleteComment(thread, commentId, deletedAt) {
       body: void 0
     } : comment
   );
-  if (!updatedComments.some((comment) => comment.deletedAt === void 0)) {
+  if (updatedComments.every((comment) => comment.deletedAt !== void 0)) {
     return {
       ...thread,
       deletedAt,
-      updatedAt: deletedAt,
-      comments: []
+      updatedAt: deletedAt
     };
   }
   return {
@@ -898,7 +970,7 @@ function deleteComment(thread, commentId, deletedAt) {
     comments: updatedComments
   };
 }
-function addReaction(thread, commentId, reaction) {
+function applyAddReaction(thread, commentId, reaction) {
   if (thread.deletedAt !== void 0) {
     return thread;
   }
@@ -925,7 +997,7 @@ function addReaction(thread, commentId, reaction) {
     comments: updatedComments
   };
 }
-function removeReaction(thread, commentId, emoji, userId, removedAt) {
+function applyRemoveReaction(thread, commentId, emoji, userId, removedAt) {
   if (thread.deletedAt !== void 0) {
     return thread;
   }
@@ -984,7 +1056,7 @@ function upsertReaction(reactions, reaction) {
 }
 
 // src/liveblocks.tsx
-var ClientContext = createContext(null);
+var ClientContext = createContext2(null);
 function missingUserError(userId) {
   return new Error(`resolveUsers didn't return anything for user '${userId}'`);
 }
@@ -993,66 +1065,30 @@ function missingRoomInfoError(roomId) {
     `resolveRoomsInfo didn't return anything for room '${roomId}'`
   );
 }
+function identity(x) {
+  return x;
+}
 var _umbrellaStores = /* @__PURE__ */ new WeakMap();
 var _extras = /* @__PURE__ */ new WeakMap();
 var _bundles = /* @__PURE__ */ new WeakMap();
 var POLLING_INTERVAL = 60 * 1e3;
-var INBOX_NOTIFICATIONS_QUERY = "INBOX_NOTIFICATIONS";
 var USER_THREADS_QUERY = "USER_THREADS";
-function selectorFor_useInboxNotifications(state) {
-  const query = state.queries[INBOX_NOTIFICATIONS_QUERY];
-  if (query === void 0 || query.isLoading) {
-    return {
-      isLoading: true
-    };
-  }
-  if (query.error !== void 0) {
-    return {
-      error: query.error,
-      isLoading: false
-    };
-  }
-  return {
-    inboxNotifications: selectInboxNotifications(state),
-    isLoading: false
-  };
-}
-function selectUserThreads(state, options) {
-  const result = applyOptimisticUpdates(state);
-  let threads = Object.values(result.threads).filter(
-    (thread) => !thread.deletedAt
-  );
-  const query = options.query;
-  if (query) {
-    threads = threads.filter(makeThreadsFilter(query));
-  }
-  return threads.sort(byMostRecentlyUpdated);
-}
-function selectUnreadInboxNotificationsCount(state) {
+function selectUnreadInboxNotificationsCount(inboxNotifications) {
   let count = 0;
-  for (const notification of selectInboxNotifications(state)) {
+  for (const notification of inboxNotifications) {
     if (notification.readAt === null || notification.readAt < notification.notifiedAt) {
       count++;
     }
   }
   return count;
 }
-function selectorFor_useUnreadInboxNotificationsCount(state) {
-  const query = state.queries[INBOX_NOTIFICATIONS_QUERY];
-  if (query === void 0 || query.isLoading) {
-    return {
-      isLoading: true
-    };
-  }
-  if (query.error !== void 0) {
-    return {
-      error: query.error,
-      isLoading: false
-    };
+function selectorFor_useUnreadInboxNotificationsCount(result) {
+  if (!result.inboxNotifications) {
+    return result;
   }
   return {
     isLoading: false,
-    count: selectUnreadInboxNotificationsCount(state)
+    count: selectUnreadInboxNotificationsCount(result.inboxNotifications)
   };
 }
 function selectorFor_useUser(state, userId) {
@@ -1091,11 +1127,17 @@ function selectorFor_useRoomInfo(state, roomId) {
     info: state.data
   };
 }
-function selectInboxNotifications(state) {
-  const result = applyOptimisticUpdates(state);
-  return Object.values(result.inboxNotifications).sort(
-    // Sort so that the most recent notifications are first
-    (a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime()
+function selectThreads(state, options) {
+  let threads = state.threads;
+  if (options.roomId !== null) {
+    threads = threads.filter((thread) => thread.roomId === options.roomId);
+  }
+  const query = options.query;
+  if (query) {
+    threads = threads.filter(makeThreadsFilter(query));
+  }
+  return threads.sort(
+    options.orderBy === "last-update" ? byMostRecentlyUpdated : byFirstCreated
   );
 }
 function getOrCreateContextBundle(client) {
@@ -1178,23 +1220,21 @@ function makeExtrasForClient(client) {
     void waitUntilInboxNotificationsLoaded().catch(() => {
     });
   }
-  function useEnableInboxNotificationsPolling() {
-    useEffect3(() => {
-      pollerSubscribers++;
-      poller.start(POLLING_INTERVAL);
-      return () => {
-        if (pollerSubscribers <= 0) {
-          console.warn(
-            `Internal unexpected behavior. Cannot decrease subscriber count for query "${INBOX_NOTIFICATIONS_QUERY}"`
-          );
-          return;
-        }
-        pollerSubscribers--;
-        if (pollerSubscribers <= 0) {
-          poller.stop();
-        }
-      };
-    }, []);
+  function startPolling() {
+    pollerSubscribers++;
+    poller.start(POLLING_INTERVAL);
+    return () => {
+      if (pollerSubscribers <= 0) {
+        console.warn(
+          `Internal unexpected behavior. Cannot decrease subscriber count for query "${INBOX_NOTIFICATIONS_QUERY}"`
+        );
+        return;
+      }
+      pollerSubscribers--;
+      if (pollerSubscribers <= 0) {
+        poller.stop();
+      }
+    };
   }
   const userThreadsPoller = makePoller(refreshUserThreads);
   let isFetchingUserThreadsUpdates = false;
@@ -1279,7 +1319,7 @@ function makeExtrasForClient(client) {
   }
   return {
     store,
-    useEnableInboxNotificationsPolling,
+    startPolling,
     waitUntilInboxNotificationsLoaded,
     loadInboxNotifications,
     incrementUserThreadsQuerySubscribers,
@@ -1294,7 +1334,7 @@ function makeLiveblocksContextBundle(client) {
   const useDeleteAllInboxNotifications2 = () => useDeleteAllInboxNotifications_withClient(client);
   function LiveblocksProvider2(props) {
     useEnsureNoLiveblocksProvider();
-    return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: client }, props.children);
+    return /* @__PURE__ */ React3.createElement(ClientContext.Provider, { value: client }, props.children);
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -1324,17 +1364,15 @@ function makeLiveblocksContextBundle(client) {
   return bundle;
 }
 function useInboxNotifications_withClient(client) {
-  const { loadInboxNotifications, store, useEnableInboxNotificationsPolling } = getExtrasForClient(client);
-  useEffect3(() => {
-    loadInboxNotifications();
-  }, [loadInboxNotifications]);
-  useEnableInboxNotificationsPolling();
+  const { loadInboxNotifications, store, startPolling } = getExtrasForClient(client);
+  useEffect3(loadInboxNotifications, [loadInboxNotifications]);
+  useEffect3(startPolling, [startPolling]);
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
-    store.get,
-    store.get,
-    selectorFor_useInboxNotifications,
-    shallow
+    store.subscribeInboxNotifications,
+    store.getInboxNotificationsAsync,
+    store.getInboxNotificationsAsync,
+    identity,
+    shallow3
   );
 }
 function useInboxNotificationsSuspense_withClient(client) {
@@ -1346,17 +1384,15 @@ function useInboxNotificationsSuspense_withClient(client) {
   return result;
 }
 function useUnreadInboxNotificationsCount_withClient(client) {
-  const { store, loadInboxNotifications, useEnableInboxNotificationsPolling } = getExtrasForClient(client);
-  useEffect3(() => {
-    loadInboxNotifications();
-  }, [loadInboxNotifications]);
-  useEnableInboxNotificationsPolling();
+  const { store, loadInboxNotifications, startPolling } = getExtrasForClient(client);
+  useEffect3(loadInboxNotifications, [loadInboxNotifications]);
+  useEffect3(startPolling, [startPolling]);
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeInboxNotifications,
+    store.getInboxNotificationsAsync,
+    store.getInboxNotificationsAsync,
     selectorFor_useUnreadInboxNotificationsCount,
-    shallow
+    shallow3
   );
 }
 function useUnreadInboxNotificationsCountSuspense_withClient(client) {
@@ -1461,13 +1497,13 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
   const { store } = getExtrasForClient(client);
   const selector = useCallback2(
     (state) => {
-      const inboxNotification = state.inboxNotifications[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
+      const inboxNotification = state.inboxNotificationsById[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
       if (inboxNotification.kind !== "thread") {
         raise(
           `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
         );
       }
-      const thread = state.threads[inboxNotification.threadId] ?? raise(
+      const thread = state.threadsById[inboxNotification.threadId] ?? raise(
         `Thread with ID "${inboxNotification.threadId}" not found, this inbox notification might not be of kind "thread"`
       );
       return thread;
@@ -1475,9 +1511,9 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
     [inboxNotificationId]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeInboxNotifications,
+    store.getInboxNotifications,
+    store.getInboxNotifications,
     selector
   );
 }
@@ -1499,7 +1535,7 @@ function useUser_withClient(client, userId) {
     getUserState,
     getUserState,
     selector,
-    shallow
+    shallow3
   );
 }
 function useUserSuspense_withClient(client, userId) {
@@ -1550,7 +1586,7 @@ function useRoomInfo_withClient(client, roomId) {
     getRoomInfoState,
     getRoomInfoState,
     selector,
-    shallow
+    shallow3
   );
 }
 function useRoomInfoSuspense_withClient(client, roomId) {
@@ -1591,13 +1627,13 @@ function createSharedContext(client) {
       useClient: useClient2,
       useUser: (userId) => useUser_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfo_withClient(client, roomId),
-      useIsInsideRoom: _useIsInsideRoom
+      useIsInsideRoom
     },
     suspense: {
       useClient: useClient2,
       useUser: (userId) => useUserSuspense_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfoSuspense_withClient(client, roomId),
-      useIsInsideRoom: _useIsInsideRoom
+      useIsInsideRoom
     }
   };
 }
@@ -1610,14 +1646,14 @@ function useEnsureNoLiveblocksProvider(options) {
   }
 }
 function useClientOrNull() {
-  return useContext(ClientContext);
+  return useContext2(ClientContext);
 }
 function useClient() {
   return useClientOrNull() ?? raise("LiveblocksProvider is missing from the React tree.");
 }
 function LiveblocksProviderWithClient(props) {
   useEnsureNoLiveblocksProvider(props);
-  return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: props.client }, props.children);
+  return /* @__PURE__ */ React3.createElement(ClientContext.Provider, { value: props.client }, props.children);
 }
 function LiveblocksProvider(props) {
   const { children, ...o } = props;
@@ -1645,7 +1681,7 @@ function LiveblocksProvider(props) {
     )
   };
   const client = useMemo(() => createClient(options), []);
-  return /* @__PURE__ */ React2.createElement(LiveblocksProviderWithClient, { client }, children);
+  return /* @__PURE__ */ React3.createElement(LiveblocksProviderWithClient, { client }, children);
 }
 function createLiveblocksContext(client) {
   return getOrCreateContextBundle(client);
@@ -1655,7 +1691,7 @@ function useUserThreads_experimental(options = {
     metadata: {}
   }
 }) {
-  const queryKey = React2.useMemo(
+  const queryKey = React3.useMemo(
     () => makeUserThreadsQueryKey(options.query),
     [options]
   );
@@ -1681,18 +1717,24 @@ function useUserThreads_experimental(options = {
         };
       }
       return {
-        threads: selectUserThreads(state, options),
+        threads: selectThreads(state, {
+          roomId: null,
+          // Do _not_ filter by roomId
+          query: options.query,
+          orderBy: "last-update"
+        }),
         isLoading: false
       };
     },
     [queryKey, options]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeThreads,
+    store.getThreads,
+    store.getThreads,
     selector,
-    shallow
+    shallow2
+    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
   );
 }
 function useUserThreadsSuspense_experimental(options = {
@@ -1700,93 +1742,216 @@ function useUserThreadsSuspense_experimental(options = {
     metadata: {}
   }
 }) {
-  const queryKey = React2.useMemo(
+  const queryKey = React3.useMemo(
     () => makeUserThreadsQueryKey(options.query),
     [options]
   );
   const client = useClient();
   const { store, getUserThreads } = getExtrasForClient(client);
-  React2.useEffect(() => {
+  React3.useEffect(() => {
     const { incrementUserThreadsQuerySubscribers } = getExtrasForClient(client);
     return incrementUserThreadsQuerySubscribers(queryKey);
   }, [client, queryKey]);
-  const query = store.get().queries[queryKey];
+  const query = store.getThreads().queries[queryKey];
   if (query === void 0 || query.isLoading) {
     throw getUserThreads(queryKey, options);
   }
-  if (query.error) {
-    throw query.error;
+  if (query.error) {
+    throw query.error;
+  }
+  const selector = useCallback2(
+    (state) => {
+      return {
+        threads: selectThreads(state, {
+          roomId: null,
+          // Do _not_ filter by roomId
+          query: options.query,
+          orderBy: "last-update"
+        }),
+        isLoading: false
+      };
+    },
+    [options]
+  );
+  return useSyncExternalStoreWithSelector(
+    store.subscribeThreads,
+    store.getThreads,
+    store.getThreads,
+    selector,
+    shallow2
+    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
+  );
+}
+function useInboxNotifications() {
+  return useInboxNotifications_withClient(useClient());
+}
+function useInboxNotificationsSuspense() {
+  return useInboxNotificationsSuspense_withClient(useClient());
+}
+function useInboxNotificationThread(inboxNotificationId) {
+  return useInboxNotificationThread_withClient(
+    useClient(),
+    inboxNotificationId
+  );
+}
+function useMarkAllInboxNotificationsAsRead() {
+  return useMarkAllInboxNotificationsAsRead_withClient(useClient());
+}
+function useMarkInboxNotificationAsRead() {
+  return useMarkInboxNotificationAsRead_withClient(useClient());
+}
+function useDeleteAllInboxNotifications() {
+  return useDeleteAllInboxNotifications_withClient(useClient());
+}
+function useDeleteInboxNotification() {
+  return useDeleteInboxNotification_withClient(useClient());
+}
+function useUnreadInboxNotificationsCount() {
+  return useUnreadInboxNotificationsCount_withClient(useClient());
+}
+function useUnreadInboxNotificationsCountSuspense() {
+  return useUnreadInboxNotificationsCountSuspense_withClient(useClient());
+}
+function useUser(userId) {
+  const client = useClient();
+  return useUser_withClient(client, userId);
+}
+function useUserSuspense(userId) {
+  const client = useClient();
+  return useUserSuspense_withClient(client, userId);
+}
+function useRoomInfo(roomId) {
+  return useRoomInfo_withClient(useClient(), roomId);
+}
+function useRoomInfoSuspense(roomId) {
+  return useRoomInfoSuspense_withClient(useClient(), roomId);
+}
+var _useInboxNotificationThread = useInboxNotificationThread;
+var _useUser = useUser;
+var _useUserSuspense = useUserSuspense;
+var _useUserThreads_experimental = useUserThreads_experimental;
+var _useUserThreadsSuspense_experimental = useUserThreadsSuspense_experimental;
+var makeUserThreadsQueryKey = (options) => `${USER_THREADS_QUERY}:${stringify(options)}`;
+
+// src/types/errors.ts
+var CreateThreadError = class extends Error {
+  constructor(cause, context) {
+    super("Create thread failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "CreateThreadError";
+  }
+};
+var DeleteThreadError = class extends Error {
+  constructor(cause, context) {
+    super("Delete thread failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "DeleteThreadError";
+  }
+};
+var EditThreadMetadataError = class extends Error {
+  constructor(cause, context) {
+    super("Edit thread metadata failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "EditThreadMetadataError";
+  }
+};
+var MarkThreadAsResolvedError = class extends Error {
+  constructor(cause, context) {
+    super("Mark thread as resolved failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkThreadAsResolvedError";
+  }
+};
+var MarkThreadAsUnresolvedError = class extends Error {
+  constructor(cause, context) {
+    super("Mark thread as unresolved failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkThreadAsUnresolvedError";
+  }
+};
+var CreateCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Create comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "CreateCommentError";
+  }
+};
+var EditCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Edit comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "EditCommentError";
+  }
+};
+var DeleteCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Delete comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "DeleteCommentError";
+  }
+};
+var AddReactionError = class extends Error {
+  constructor(cause, context) {
+    super("Add reaction failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "AddReactionError";
+  }
+};
+var RemoveReactionError = class extends Error {
+  constructor(cause, context) {
+    super("Remove reaction failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "RemoveReactionError";
+  }
+};
+var MarkInboxNotificationAsReadError = class extends Error {
+  constructor(cause, context) {
+    super("Mark inbox notification as read failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkInboxNotificationAsReadError";
+  }
+};
+var UpdateNotificationSettingsError = class extends Error {
+  constructor(cause, context) {
+    super("Update notification settings failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "UpdateNotificationSettingsError";
   }
-  const selector = useCallback2(
-    (state) => {
-      return {
-        threads: selectUserThreads(state, options),
-        isLoading: false
-      };
-    },
-    [options]
-  );
-  return useSyncExternalStoreWithSelector(
-    store.subscribe,
-    store.get,
-    store.get,
-    selector,
-    shallow
-  );
-}
-function useInboxNotifications() {
-  return useInboxNotifications_withClient(useClient());
-}
-function useInboxNotificationsSuspense() {
-  return useInboxNotificationsSuspense_withClient(useClient());
-}
-function useInboxNotificationThread(inboxNotificationId) {
-  return useInboxNotificationThread_withClient(
-    useClient(),
-    inboxNotificationId
-  );
-}
-function useMarkAllInboxNotificationsAsRead() {
-  return useMarkAllInboxNotificationsAsRead_withClient(useClient());
-}
-function useMarkInboxNotificationAsRead() {
-  return useMarkInboxNotificationAsRead_withClient(useClient());
-}
-function useDeleteAllInboxNotifications() {
-  return useDeleteAllInboxNotifications_withClient(useClient());
-}
-function useDeleteInboxNotification() {
-  return useDeleteInboxNotification_withClient(useClient());
-}
-function useUnreadInboxNotificationsCount() {
-  return useUnreadInboxNotificationsCount_withClient(useClient());
-}
-function useUnreadInboxNotificationsCountSuspense() {
-  return useUnreadInboxNotificationsCountSuspense_withClient(useClient());
-}
-function useUser(userId) {
-  const client = useClient();
-  return useUser_withClient(client, userId);
-}
-function useUserSuspense(userId) {
-  const client = useClient();
-  return useUserSuspense_withClient(client, userId);
-}
-function useRoomInfo(roomId) {
-  return useRoomInfo_withClient(useClient(), roomId);
-}
-function useRoomInfoSuspense(roomId) {
-  return useRoomInfoSuspense_withClient(useClient(), roomId);
-}
-var _useInboxNotificationThread = useInboxNotificationThread;
-var _useUser = useUser;
-var _useUserSuspense = useUserSuspense;
-var _useUserThreads_experimental = useUserThreads_experimental;
-var _useUserThreadsSuspense_experimental = useUserThreadsSuspense_experimental;
-var makeUserThreadsQueryKey = (options) => `${USER_THREADS_QUERY}:${stringify(options)}`;
+};
+
+// src/room.tsx
+import { shallow as shallow4 } from "@liveblocks/client";
+import {
+  CommentsApiError,
+  console as console3,
+  createCommentId,
+  createThreadId,
+  deprecateIf,
+  errorIf,
+  kInternal as kInternal2,
+  makeEventSource,
+  makePoller as makePoller2,
+  NotificationsApiError,
+  ServerMsgCode,
+  stringify as stringify2
+} from "@liveblocks/core";
+import * as React5 from "react";
+import { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from "use-sync-external-store/shim/with-selector.js";
 
 // src/use-scroll-to-comment-on-load-effect.ts
-import * as React3 from "react";
+import * as React4 from "react";
 function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
   if (shouldScrollOnLoad === false) return;
   if (state.isLoading) return;
@@ -1805,7 +1970,7 @@ function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
   comment.scrollIntoView();
 }
 function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
-  React3.useEffect(
+  React4.useEffect(
     () => {
       handleScrollToCommentOnLoad(shouldScrollOnLoad, state);
     },
@@ -1818,7 +1983,7 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 var SMOOTH_DELAY = 1e3;
 var noop2 = () => {
 };
-var identity = (x) => x;
+var identity2 = (x) => x;
 var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\u2019re using React ${reactVersion}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
 
     import { unstable_batchedUpdates } from "react-dom";  // or "react-native"
@@ -1832,13 +1997,10 @@ var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\
 Why? Please see https://liveblocks.io/docs/platform/troubleshooting#stale-props-zombie-child for more information`;
 var superfluous_unstable_batchedUpdates = "You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";
 function useSyncExternalStore2(s, gs, gss) {
-  return useSyncExternalStoreWithSelector2(s, gs, gss, identity);
+  return useSyncExternalStoreWithSelector2(s, gs, gss, identity2);
 }
 var STABLE_EMPTY_LIST = Object.freeze([]);
 var POLLING_INTERVAL2 = 5 * 60 * 1e3;
-function makeNotificationSettingsQueryKey(roomId) {
-  return `${roomId}:NOTIFICATION_SETTINGS`;
-}
 function alwaysEmptyList() {
   return STABLE_EMPTY_LIST;
 }
@@ -1848,22 +2010,6 @@ function alwaysNull() {
 function selectorFor_useOthersConnectionIds(others) {
   return others.map((user) => user.connectionId);
 }
-function selectRoomThreads(roomId, state, options) {
-  const result = applyOptimisticUpdates(state);
-  let threads = Object.values(result.threads).filter(
-    (thread) => !thread.deletedAt
-  );
-  threads = threads.filter((thread) => thread.roomId === roomId);
-  const query = options.query;
-  if (query) {
-    threads = threads.filter(makeThreadsFilter(query));
-  }
-  return threads.sort(byFirstCreated);
-}
-function selectNotificationSettings(roomId, state) {
-  const { notificationSettings } = applyOptimisticUpdates(state);
-  return nn(notificationSettings[roomId]);
-}
 function makeMutationContext(room) {
   const cannotUseUntil = "This mutation cannot be used until";
   const needsPresence = `${cannotUseUntil} connected to the Liveblocks room`;
@@ -1992,7 +2138,7 @@ function makeExtrasForClient2(client) {
     }
   }
   async function getRoomVersions(room, { retryCount } = { retryCount: 0 }) {
-    const queryKey = getVersionsQueryKey(room.id);
+    const queryKey = makeVersionsQueryKey(room.id);
     const existingRequest = requestsByQuery.get(queryKey);
     if (existingRequest !== void 0) return existingRequest;
     const request = room[kInternal2].listTextVersions();
@@ -2052,7 +2198,8 @@ function makeExtrasForClient2(client) {
     }
     return;
   }
-  async function getInboxNotificationSettings(room, queryKey, { retryCount } = { retryCount: 0 }) {
+  async function getInboxNotificationSettings(room, { retryCount } = { retryCount: 0 }) {
+    const queryKey = makeNotificationSettingsQueryKey(room.id);
     const existingRequest = requestsByQuery.get(queryKey);
     if (existingRequest !== void 0) return existingRequest;
     try {
@@ -2064,7 +2211,7 @@ function makeExtrasForClient2(client) {
     } catch (err) {
       requestsByQuery.delete(queryKey);
       retryError(() => {
-        void getInboxNotificationSettings(room, queryKey, {
+        void getInboxNotificationSettings(room, {
           retryCount: retryCount + 1
         });
       }, retryCount);
@@ -2097,10 +2244,9 @@ function makeExtrasForClient2(client) {
     onMutationFailure
   };
 }
-var RoomContext = React4.createContext(null);
 function makeRoomContextBundle(client) {
   function RoomProvider_withImplicitLiveblocksProvider(props) {
-    return /* @__PURE__ */ React4.createElement(LiveblocksProviderWithClient, { client, allowNesting: true }, /* @__PURE__ */ React4.createElement(RoomProvider, { ...props }));
+    return /* @__PURE__ */ React5.createElement(LiveblocksProviderWithClient, { client, allowNesting: true }, /* @__PURE__ */ React5.createElement(RoomProvider, { ...props }));
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -2202,10 +2348,10 @@ function makeRoomContextBundle(client) {
 }
 function RoomProvider(props) {
   const client = useClient();
-  const [cache] = React4.useState(
+  const [cache] = React5.useState(
     () => /* @__PURE__ */ new Map()
   );
-  const stableEnterRoom = React4.useCallback(
+  const stableEnterRoom = React5.useCallback(
     (roomId, options) => {
       const cached = cache.get(roomId);
       if (cached) return cached;
@@ -2220,7 +2366,7 @@ function RoomProvider(props) {
     },
     [client, cache]
   );
-  return /* @__PURE__ */ React4.createElement(
+  return /* @__PURE__ */ React5.createElement(
     RoomProviderInner,
     {
       ...props,
@@ -2240,7 +2386,7 @@ function RoomProviderInner(props) {
     if (!isString(roomId)) {
       throw new Error("RoomProvider id property should be a string.");
     }
-    const majorReactVersion = parseInt(React4.version) || 1;
+    const majorReactVersion = parseInt(React5.version) || 1;
     const oldReactVersion = majorReactVersion < 18;
     errorIf(
       oldReactVersion && props.unstable_batchedUpdates === void 0,
@@ -2257,14 +2403,14 @@ function RoomProviderInner(props) {
     unstable_batchedUpdates: props.unstable_batchedUpdates,
     autoConnect: props.autoConnect ?? typeof window !== "undefined"
   });
-  const [{ room }, setRoomLeavePair] = React4.useState(
+  const [{ room }, setRoomLeavePair] = React5.useState(
     () => stableEnterRoom(roomId, {
       ...frozenProps,
       autoConnect: false
       // Deliberately using false here on the first render, see below
     })
   );
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     const { store } = getExtrasForClient2(client);
     async function handleCommentEvent(message) {
       if (message.type === ServerMsgCode.THREAD_DELETED) {
@@ -2277,7 +2423,7 @@ function RoomProviderInner(props) {
         return;
       }
       const { thread, inboxNotification } = info;
-      const existingThread = store.get().threads[message.threadId];
+      const existingThread = store.getThreads().threadsById[message.threadId];
       switch (message.type) {
         case ServerMsgCode.COMMENT_EDITED:
         case ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -2299,11 +2445,11 @@ function RoomProviderInner(props) {
       (message) => void handleCommentEvent(message)
     );
   }, [client, room]);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     const { getThreadsUpdates } = getExtrasForClient2(client);
     void getThreadsUpdates(room.id);
   }, [client, room.id]);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     function handleIsOnline() {
       const { getThreadsUpdates } = getExtrasForClient2(client);
       void getThreadsUpdates(room.id);
@@ -2313,7 +2459,7 @@ function RoomProviderInner(props) {
       window.removeEventListener("online", handleIsOnline);
     };
   }, [client, room.id]);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     const pair = stableEnterRoom(roomId, frozenProps);
     setRoomLeavePair(pair);
     const { room: room2, leave } = pair;
@@ -2324,7 +2470,7 @@ function RoomProviderInner(props) {
       leave();
     };
   }, [roomId, frozenProps, stableEnterRoom]);
-  return /* @__PURE__ */ React4.createElement(RoomContext.Provider, { value: room }, props.children);
+  return /* @__PURE__ */ React5.createElement(RoomContext.Provider, { value: room }, props.children);
 }
 function useRoom() {
   const room = useRoomOrNull();
@@ -2333,10 +2479,6 @@ function useRoom() {
   }
   return room;
 }
-function useIsInsideRoom() {
-  const room = useRoomOrNull();
-  return room !== null;
-}
 function useStatus() {
   const room = useRoom();
   const subscribe = room.events.status.subscribe;
@@ -2361,9 +2503,9 @@ function useStorageStatusImmediate() {
 }
 function useStorageStatusSmooth() {
   const room = useRoom();
-  const [status, setStatus] = React4.useState(room.getStorageStatus);
+  const [status, setStatus] = React5.useState(room.getStorageStatus);
   const oldStatus = useLatest(room.getStorageStatus());
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     let timeoutId;
     const unsub = room.events.storageStatus.subscribe((newStatus) => {
       if (oldStatus.current === "synchronizing" && newStatus === "synchronized") {
@@ -2385,7 +2527,7 @@ function useBatch() {
 }
 function useBroadcastEvent() {
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (event, options = { shouldQueueEventIfNotReady: false }) => {
       room.broadcastEvent(event, options);
     },
@@ -2395,7 +2537,7 @@ function useBroadcastEvent() {
 function useOthersListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  React5.useEffect(
     () => room.events.others.subscribe((event) => savedCallback.current(event)),
     [room, savedCallback]
   );
@@ -2403,7 +2545,7 @@ function useOthersListener(callback) {
 function useLostConnectionListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  React5.useEffect(
     () => room.events.lostConnection.subscribe(
       (event) => savedCallback.current(event)
     ),
@@ -2413,7 +2555,7 @@ function useLostConnectionListener(callback) {
 function useErrorListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  React5.useEffect(
     () => room.events.error.subscribe((e) => savedCallback.current(e)),
     [room, savedCallback]
   );
@@ -2421,7 +2563,7 @@ function useErrorListener(callback) {
 function useEventListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     const listener = (eventData) => {
       savedCallback.current(eventData);
     };
@@ -2453,8 +2595,8 @@ function useSelf(maybeSelector, isEqual) {
   const room = useRoom();
   const subscribe = room.events.self.subscribe;
   const getSnapshot = room.getSelf;
-  const selector = maybeSelector ?? identity;
-  const wrappedSelector = React4.useCallback(
+  const selector = maybeSelector ?? identity2;
+  const wrappedSelector = React5.useCallback(
     (me) => me !== null ? selector(me) : null,
     [selector]
   );
@@ -2487,16 +2629,16 @@ function useOthers(selector, isEqual) {
     subscribe,
     getSnapshot,
     getServerSnapshot,
-    selector ?? identity,
+    selector ?? identity2,
     isEqual
   );
 }
 function useOthersMapped(itemSelector, itemIsEqual) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = React5.useCallback(
     (others) => others.map((other) => [other.connectionId, itemSelector(other)]),
     [itemSelector]
   );
-  const wrappedIsEqual = React4.useCallback(
+  const wrappedIsEqual = React5.useCallback(
     (a, b) => {
       const eq = itemIsEqual ?? Object.is;
       return a.length === b.length && a.every((atuple, index) => {
@@ -2509,18 +2651,18 @@ function useOthersMapped(itemSelector, itemIsEqual) {
   return useOthers(wrappedSelector, wrappedIsEqual);
 }
 function useOthersConnectionIds() {
-  return useOthers(selectorFor_useOthersConnectionIds, shallow2);
+  return useOthers(selectorFor_useOthersConnectionIds, shallow4);
 }
 var NOT_FOUND = Symbol();
 function useOther(connectionId, selector, isEqual) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = React5.useCallback(
     (others) => {
       const other2 = others.find((other3) => other3.connectionId === connectionId);
       return other2 !== void 0 ? selector(other2) : NOT_FOUND;
     },
     [connectionId, selector]
   );
-  const wrappedIsEqual = React4.useCallback(
+  const wrappedIsEqual = React5.useCallback(
     (prev, curr) => {
       if (prev === NOT_FOUND || curr === NOT_FOUND) {
         return prev === curr;
@@ -2551,15 +2693,15 @@ function useStorageRoot() {
 function useStorage(selector, isEqual) {
   const room = useRoom();
   const rootOrNull = useMutableStorageRoot();
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = React5.useCallback(
     (rootOrNull2) => rootOrNull2 !== null ? selector(rootOrNull2) : null,
     [selector]
   );
-  const subscribe = React4.useCallback(
+  const subscribe = React5.useCallback(
     (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop2,
     [room, rootOrNull]
   );
-  const getSnapshot = React4.useCallback(() => {
+  const getSnapshot = React5.useCallback(() => {
     if (rootOrNull === null) {
       return null;
     } else {
@@ -2579,7 +2721,7 @@ function useStorage(selector, isEqual) {
 }
 function useMutation(callback, deps) {
   const room = useRoom();
-  return React4.useMemo(
+  return React5.useMemo(
     () => {
       return (...args) => (
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -2604,16 +2746,16 @@ function useThreads(options = {
   const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
-  const queryKey = React4.useMemo(
+  const queryKey = React5.useMemo(
     () => generateQueryKey(room.id, options.query),
     [room, options]
   );
   const { store, getThreadsAndInboxNotifications, incrementQuerySubscribers } = getExtrasForClient2(client);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     void getThreadsAndInboxNotifications(room, queryKey, options);
     return incrementQuerySubscribers(queryKey);
   }, [room, queryKey]);
-  const selector = React4.useCallback(
+  const selector = React5.useCallback(
     (state2) => {
       const query = state2.queries[queryKey];
       if (query === void 0 || query.isLoading) {
@@ -2622,7 +2764,11 @@ function useThreads(options = {
         };
       }
       return {
-        threads: selectRoomThreads(room.id, state2, options),
+        threads: selectThreads(state2, {
+          roomId: room.id,
+          query: options.query,
+          orderBy: "age"
+        }),
         isLoading: false,
         error: query.error
       };
@@ -2631,9 +2777,9 @@ function useThreads(options = {
     // eslint-disable-line react-hooks/exhaustive-deps
   );
   const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeThreads,
+    store.getThreads,
+    store.getThreads,
     selector
   );
   useScrollToCommentOnLoadEffect(scrollOnLoad, state);
@@ -2643,14 +2789,14 @@ function useCommentsErrorListener(callback) {
   const client = useClient();
   const savedCallback = useLatest(callback);
   const { commentsErrorEventSource } = getExtrasForClient2(client);
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     return commentsErrorEventSource.subscribe(savedCallback.current);
   }, [savedCallback, commentsErrorEventSource]);
 }
 function useCreateThread() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (options) => {
       const body = options.body;
       const metadata = options.metadata ?? {};
@@ -2707,10 +2853,10 @@ function useCreateThread() {
 function useDeleteThread() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (threadId) => {
       const { store, onMutationFailure } = getExtrasForClient2(client);
-      const thread = store.get().threads[threadId];
+      const thread = store.getThreads().threadsById[threadId];
       const userId = getCurrentUserId(room);
       if (thread?.comments?.[0]?.userId !== userId) {
         throw new Error("Only the thread creator can delete the thread");
@@ -2738,7 +2884,7 @@ function useDeleteThread() {
 function useEditThreadMetadata() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (options) => {
       if (!options.metadata) {
         return;
@@ -2756,10 +2902,10 @@ function useEditThreadMetadata() {
       room.editThreadMetadata({ threadId, metadata }).then(
         (metadata2) => (
           // Replace the optimistic update by the real thing
-          store.updateThread(
+          store.patchThread(
             threadId,
             optimisticUpdateId,
-            (thread) => ({ ...thread, metadata: metadata2 }),
+            { metadata: metadata2 },
             updatedAt
           )
         ),
@@ -2780,7 +2926,7 @@ function useEditThreadMetadata() {
 function useCreateComment() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     ({ threadId, body }) => {
       const commentId = createCommentId();
       const createdAt = /* @__PURE__ */ new Date();
@@ -2822,11 +2968,11 @@ function useCreateComment() {
 function useEditComment() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     ({ threadId, commentId, body }) => {
       const editedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getExtrasForClient2(client);
-      const thread = store.get().threads[threadId];
+      const thread = store.getThreads().threadsById[threadId];
       if (thread === void 0) {
         console3.warn(
           `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
@@ -2852,11 +2998,7 @@ function useEditComment() {
       });
       room.editComment({ threadId, commentId, body }).then(
         (editedComment) => {
-          store.updateThread(
-            threadId,
-            optimisticUpdateId,
-            (thread2) => upsertComment(thread2, editedComment)
-          );
+          store.editComment(threadId, optimisticUpdateId, editedComment);
         },
         (err) => onMutationFailure(
           err,
@@ -2876,7 +3018,7 @@ function useEditComment() {
 function useDeleteComment() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     ({ threadId, commentId }) => {
       const deletedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getExtrasForClient2(client);
@@ -2889,10 +3031,10 @@ function useDeleteComment() {
       });
       room.deleteComment({ threadId, commentId }).then(
         () => {
-          store.updateThread(
+          store.deleteComment(
             threadId,
             optimisticUpdateId,
-            (thread) => deleteComment(thread, commentId, deletedAt),
+            commentId,
             deletedAt
           );
         },
@@ -2913,7 +3055,7 @@ function useDeleteComment() {
 function useAddReaction() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     ({ threadId, commentId, emoji }) => {
       const createdAt = /* @__PURE__ */ new Date();
       const userId = getCurrentUserId(room);
@@ -2930,10 +3072,11 @@ function useAddReaction() {
       });
       room.addReaction({ threadId, commentId, emoji }).then(
         (addedReaction) => {
-          store.updateThread(
+          store.addReaction(
             threadId,
             optimisticUpdateId,
-            (thread) => addReaction(thread, commentId, addedReaction),
+            commentId,
+            addedReaction,
             createdAt
           );
         },
@@ -2955,7 +3098,7 @@ function useAddReaction() {
 function useRemoveReaction() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     ({ threadId, commentId, emoji }) => {
       const userId = getCurrentUserId(room);
       const removedAt = /* @__PURE__ */ new Date();
@@ -2970,10 +3113,12 @@ function useRemoveReaction() {
       });
       room.removeReaction({ threadId, commentId, emoji }).then(
         () => {
-          store.updateThread(
+          store.removeReaction(
             threadId,
             optimisticUpdateId,
-            (thread) => removeReaction(thread, commentId, emoji, userId, removedAt),
+            commentId,
+            emoji,
+            userId,
             removedAt
           );
         },
@@ -2995,11 +3140,11 @@ function useRemoveReaction() {
 function useMarkThreadAsRead() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (threadId) => {
       const { store, onMutationFailure } = getExtrasForClient2(client);
       const inboxNotification = Object.values(
-        store.get().inboxNotifications
+        store.getInboxNotifications().inboxNotificationsById
       ).find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
@@ -3036,7 +3181,7 @@ function useMarkThreadAsRead() {
 function useMarkThreadAsResolved() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getExtrasForClient2(client);
@@ -3047,10 +3192,10 @@ function useMarkThreadAsResolved() {
       });
       room.markThreadAsResolved(threadId).then(
         () => {
-          store.updateThread(
+          store.patchThread(
             threadId,
             optimisticUpdateId,
-            (thread) => ({ ...thread, resolved: true }),
+            { resolved: true },
             updatedAt
           );
         },
@@ -3070,7 +3215,7 @@ function useMarkThreadAsResolved() {
 function useMarkThreadAsUnresolved() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getExtrasForClient2(client);
@@ -3081,10 +3226,10 @@ function useMarkThreadAsUnresolved() {
       });
       room.markThreadAsUnresolved(threadId).then(
         () => {
-          store.updateThread(
+          store.patchThread(
             threadId,
             optimisticUpdateId,
-            (thread) => ({ ...thread, resolved: false }),
+            { resolved: false },
             updatedAt
           );
         },
@@ -3104,12 +3249,12 @@ function useMarkThreadAsUnresolved() {
 function useThreadSubscription(threadId) {
   const client = useClient();
   const { store } = getExtrasForClient2(client);
-  const selector = React4.useCallback(
+  const selector = React5.useCallback(
     (state) => {
-      const inboxNotification = selectInboxNotifications(state).find(
+      const inboxNotification = state.inboxNotifications.find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
-      const thread = state.threads[threadId];
+      const thread = state.threadsById[threadId];
       if (inboxNotification === void 0 || thread === void 0) {
         return {
           status: "not-subscribed"
@@ -3123,54 +3268,68 @@ function useThreadSubscription(threadId) {
     [threadId]
   );
   return useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeThreads,
+    store.getThreads,
+    store.getThreads,
     selector
   );
 }
 function useRoomNotificationSettings() {
+  const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
   const client = useClient();
   const room = useRoom();
   const { store } = getExtrasForClient2(client);
-  React4.useEffect(() => {
+  const getter = React5.useCallback(
+    () => store.getNotificationSettingsAsync(room.id),
+    [store, room.id]
+  );
+  React5.useEffect(() => {
     const { getInboxNotificationSettings } = getExtrasForClient2(client);
-    const queryKey = makeNotificationSettingsQueryKey(room.id);
-    void getInboxNotificationSettings(room, queryKey);
+    void getInboxNotificationSettings(room);
   }, [client, room]);
+  const settings = useSyncExternalStoreWithSelector2(
+    store.subscribeNotificationSettings,
+    getter,
+    getter,
+    identity2,
+    shallow4
+  );
+  return React5.useMemo(() => {
+    return [settings, updateRoomNotificationSettings];
+  }, [settings, updateRoomNotificationSettings]);
+}
+function useRoomNotificationSettingsSuspense() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
-  const selector = React4.useCallback(
-    (state) => {
-      const query = state.queries[makeNotificationSettingsQueryKey(room.id)];
-      if (query === void 0 || query.isLoading) {
-        return { isLoading: true };
-      }
-      if (query.error !== void 0) {
-        return { isLoading: false, error: query.error };
-      }
-      return {
-        isLoading: false,
-        settings: selectNotificationSettings(room.id, state)
-      };
-    },
-    [room]
+  const client = useClient();
+  const room = useRoom();
+  const { store } = getExtrasForClient2(client);
+  const getter = React5.useCallback(
+    () => store.getNotificationSettingsAsync(room.id),
+    [store, room.id]
   );
   const settings = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
-    selector
+    store.subscribeNotificationSettings,
+    getter,
+    getter,
+    identity2,
+    shallow4
   );
-  return React4.useMemo(() => {
+  if (settings.isLoading) {
+    const { getInboxNotificationSettings } = getExtrasForClient2(client);
+    throw getInboxNotificationSettings(room);
+  } else if (settings.error) {
+    throw settings.error;
+  }
+  return React5.useMemo(() => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
 function useHistoryVersionData(versionId) {
-  const [state, setState] = React4.useState({
+  const [state, setState] = React5.useState({
     isLoading: true
   });
   const room = useRoom();
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     setState({ isLoading: true });
     const load = async () => {
       try {
@@ -3197,40 +3356,50 @@ function useHistoryVersionData(versionId) {
 function useHistoryVersions() {
   const client = useClient();
   const room = useRoom();
-  const queryKey = getVersionsQueryKey(room.id);
   const { store, getRoomVersions } = getExtrasForClient2(client);
-  React4.useEffect(() => {
+  const getter = React5.useCallback(
+    () => store.getVersionsAsync(room.id),
+    [store, room.id]
+  );
+  React5.useEffect(() => {
     void getRoomVersions(room);
   }, [room]);
-  const selector = React4.useCallback(
-    (state2) => {
-      const query = state2.queries[queryKey];
-      if (query === void 0 || query.isLoading) {
-        return {
-          isLoading: true
-        };
-      }
-      return {
-        versions: state2.versions[room.id],
-        isLoading: false,
-        error: query.error
-      };
-    },
-    [room, queryKey]
-    // eslint-disable-line react-hooks/exhaustive-deps
-  );
   const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
-    selector
+    store.subscribeVersions,
+    getter,
+    getter,
+    identity2,
+    shallow4
+  );
+  return state;
+}
+function useHistoryVersionsSuspense() {
+  const client = useClient();
+  const room = useRoom();
+  const { store } = getExtrasForClient2(client);
+  const getter = React5.useCallback(
+    () => store.getVersionsAsync(room.id),
+    [store, room.id]
   );
+  const state = useSyncExternalStoreWithSelector2(
+    store.subscribeVersions,
+    getter,
+    getter,
+    identity2,
+    shallow4
+  );
+  if (state.isLoading) {
+    const { getRoomVersions } = getExtrasForClient2(client);
+    throw getRoomVersions(room);
+  } else if (state.error) {
+    throw state.error;
+  }
   return state;
 }
 function useUpdateRoomNotificationSettings() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return React5.useCallback(
     (settings) => {
       const { store, onMutationFailure } = getExtrasForClient2(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
@@ -3318,115 +3487,51 @@ function useThreadsSuspense(options = {
   const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
-  const queryKey = React4.useMemo(
+  const queryKey = React5.useMemo(
     () => generateQueryKey(room.id, options.query),
     [room, options]
   );
   const { store, getThreadsAndInboxNotifications } = getExtrasForClient2(client);
-  const query = store.get().queries[queryKey];
+  const query = store.getThreads().queries[queryKey];
   if (query === void 0 || query.isLoading) {
     throw getThreadsAndInboxNotifications(room, queryKey, options);
   }
   if (query.error) {
     throw query.error;
   }
-  const selector = React4.useCallback(
+  const selector = React5.useCallback(
     (state2) => {
       return {
-        threads: selectRoomThreads(room.id, state2, options),
+        threads: selectThreads(state2, {
+          roomId: room.id,
+          query: options.query,
+          orderBy: "age"
+        }),
         isLoading: false
       };
     },
     [room, queryKey]
     // eslint-disable-line react-hooks/exhaustive-deps
   );
-  React4.useEffect(() => {
+  React5.useEffect(() => {
     const { incrementQuerySubscribers } = getExtrasForClient2(client);
     return incrementQuerySubscribers(queryKey);
   }, [client, queryKey]);
   const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
+    store.subscribeThreads,
+    store.getThreads,
+    store.getThreads,
     selector
   );
   useScrollToCommentOnLoadEffect(scrollOnLoad, state);
   return state;
 }
-function useHistoryVersionsSuspense() {
-  const client = useClient();
-  const room = useRoom();
-  const queryKey = getVersionsQueryKey(room.id);
-  const { store, getRoomVersions } = getExtrasForClient2(client);
-  const query = store.get().queries[queryKey];
-  if (query === void 0 || query.isLoading) {
-    throw getRoomVersions(room);
-  }
-  if (query.error) {
-    throw query.error;
-  }
-  const selector = React4.useCallback(
-    (state2) => {
-      return {
-        versions: state2.versions[room.id],
-        isLoading: false
-      };
-    },
-    [room, queryKey]
-    // eslint-disable-line react-hooks/exhaustive-deps
-  );
-  const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
-    selector
-  );
-  return state;
-}
-function useRoomNotificationSettingsSuspense() {
-  const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
-  const client = useClient();
-  const room = useRoom();
-  const queryKey = makeNotificationSettingsQueryKey(room.id);
-  const { store, getInboxNotificationSettings } = getExtrasForClient2(client);
-  const query = store.get().queries[queryKey];
-  if (query === void 0 || query.isLoading) {
-    throw getInboxNotificationSettings(room, queryKey);
-  }
-  if (query.error) {
-    throw query.error;
-  }
-  const selector = React4.useCallback(
-    (state) => {
-      return {
-        isLoading: false,
-        settings: selectNotificationSettings(room.id, state)
-      };
-    },
-    [room]
-  );
-  const settings = useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.get,
-    store.get,
-    selector
-  );
-  return React4.useMemo(() => {
-    return [settings, updateRoomNotificationSettings];
-  }, [settings, updateRoomNotificationSettings]);
-}
-function useRoomOrNull() {
-  return React4.useContext(RoomContext);
-}
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
 }
 function generateQueryKey(roomId, options) {
   return `${roomId}-${stringify2(options ?? {})}`;
 }
-function getVersionsQueryKey(roomId) {
-  return `${roomId}-VERSIONS`;
-}
 var _RoomProvider = RoomProvider;
 var _useBroadcastEvent = useBroadcastEvent;
 var _useOthersListener = useOthersListener;
@@ -3469,9 +3574,29 @@ export {
   PKG_VERSION,
   PKG_FORMAT,
   ClientSideSuspense,
-  CreateThreadError,
-  selectRoomThreads,
   RoomContext,
+  ClientContext,
+  selectThreads,
+  getUmbrellaStoreForClient,
+  useClient,
+  LiveblocksProvider,
+  createLiveblocksContext,
+  useInboxNotifications,
+  useInboxNotificationsSuspense,
+  useMarkAllInboxNotificationsAsRead,
+  useMarkInboxNotificationAsRead,
+  useDeleteAllInboxNotifications,
+  useDeleteInboxNotification,
+  useUnreadInboxNotificationsCount,
+  useUnreadInboxNotificationsCountSuspense,
+  useRoomInfo,
+  useRoomInfoSuspense,
+  _useInboxNotificationThread,
+  _useUser,
+  _useUserSuspense,
+  _useUserThreads_experimental,
+  _useUserThreadsSuspense_experimental,
+  CreateThreadError,
   useStatus,
   useStorageStatus,
   useBatch,
@@ -3525,26 +3650,6 @@ export {
   _useSelf,
   _useSelfSuspense,
   _useStorageRoot,
-  _useUpdateMyPresence,
-  ClientContext,
-  getUmbrellaStoreForClient,
-  useClient,
-  LiveblocksProvider,
-  createLiveblocksContext,
-  useInboxNotifications,
-  useInboxNotificationsSuspense,
-  useMarkAllInboxNotificationsAsRead,
-  useMarkInboxNotificationAsRead,
-  useDeleteAllInboxNotifications,
-  useDeleteInboxNotification,
-  useUnreadInboxNotificationsCount,
-  useUnreadInboxNotificationsCountSuspense,
-  useRoomInfo,
-  useRoomInfoSuspense,
-  _useInboxNotificationThread,
-  _useUser,
-  _useUserSuspense,
-  _useUserThreads_experimental,
-  _useUserThreadsSuspense_experimental
+  _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-OKR7ROQ5.mjs.map
+//# sourceMappingURL=chunk-QC6HYSYS.mjs.map