@liveblocks/react 2.8.2 → 2.9.0-rc1

package/dist/{chunk-HPI4YG7I.js → chunk-7P6EIISH.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "2.8.2";
+var PKG_VERSION = "2.9.0-rc1";
 var PKG_FORMAT = "cjs";
 
 // src/ClientSideSuspense.tsx
@@ -24,27 +24,37 @@ function useIsInsideRoom() {
   return room !== null;
 }
 
-// src/liveblocks.tsx
-
-
-
-
+// src/umbrella-store.ts
 
 
 
 
 
 
-var _core = require('@liveblocks/core');
 
 
 
 
 
 
+var _core = require('@liveblocks/core');
 
-var _indexjs = require('use-sync-external-store/shim/index.js');
-var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');
+// src/lib/autobind.ts
+function autobind(self) {
+  const seen = /* @__PURE__ */ new Set();
+  seen.add("constructor");
+  let obj = self.constructor.prototype;
+  do {
+    for (const key of Reflect.ownKeys(obj)) {
+      if (seen.has(key)) continue;
+      const descriptor = Reflect.getOwnPropertyDescriptor(obj, key);
+      if (typeof _optionalChain([descriptor, 'optionalAccess', _ => _.value]) === "function") {
+        seen.add(key);
+        self[key] = self[key].bind(self);
+      }
+    }
+  } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
+}
 
 // src/lib/compare.ts
 function byFirstCreated(a, b) {
@@ -90,131 +100,204 @@ function matchesOperator(value, op) {
   }
 }
 
-// src/lib/retry-error.ts
-var MAX_ERROR_RETRY_COUNT = 5;
-var ERROR_RETRY_INTERVAL = 5e3;
-function retryError(action, retryCount) {
-  if (retryCount >= MAX_ERROR_RETRY_COUNT) return;
-  const timeout = Math.pow(2, retryCount) * ERROR_RETRY_INTERVAL;
-  setTimeout(() => {
-    void action();
-  }, timeout);
+// src/umbrella-store.ts
+var ASYNC_OK = Object.freeze({ isLoading: false, data: void 0 });
+function makeRoomThreadsQueryKey(roomId, query) {
+  return `${roomId}-${_core.stringify.call(void 0, _nullishCoalesce(query, () => ( {})))}`;
 }
-
-// src/lib/shallow2.ts
-
-function shallow2(a, b) {
-  if (!_core.isPlainObject.call(void 0, a) || !_core.isPlainObject.call(void 0, b)) {
-    return _core.shallow.call(void 0, a, b);
+function makeUserThreadsQueryKey(query) {
+  return `USER_THREADS:${_core.stringify.call(void 0, _nullishCoalesce(query, () => ( {})))}`;
+}
+function makeNotificationSettingsQueryKey(roomId) {
+  return `${roomId}:NOTIFICATION_SETTINGS`;
+}
+function makeVersionsQueryKey(roomId) {
+  return `${roomId}-VERSIONS`;
+}
+function selectThreads(state, options) {
+  let threads = state.threads;
+  if (options.roomId !== null) {
+    threads = threads.filter((thread) => thread.roomId === options.roomId);
   }
-  const keysA = Object.keys(a);
-  if (keysA.length !== Object.keys(b).length) {
-    return false;
+  const query = options.query;
+  if (query) {
+    threads = threads.filter(makeThreadsFilter(query));
   }
-  return keysA.every(
-    (key) => Object.prototype.hasOwnProperty.call(b, key) && _core.shallow.call(void 0, a[key], b[key])
+  return threads.sort(
+    options.orderBy === "last-update" ? byMostRecentlyUpdated : byFirstCreated
   );
 }
-
-// src/lib/use-initial.ts
-
-
-// src/lib/use-latest.ts
-
-function useLatest(value) {
-  const ref = _react.useRef.call(void 0, value);
-  _react.useEffect.call(void 0, () => {
-    ref.current = value;
-  }, [value]);
-  return ref;
-}
-
-// src/lib/use-initial.ts
-var noop = (state) => state;
-function useInitial(value) {
-  return _react.useReducer.call(void 0, noop, value)[0];
-}
-function useInitialUnlessFunction(latestValue) {
-  const frozenValue = useInitial(latestValue);
-  if (typeof frozenValue === "function") {
-    const ref = useLatest(latestValue);
-    return _react.useCallback.call(void 0, (...args) => ref.current(...args), [
-      ref
-    ]);
-  } else {
-    return frozenValue;
+function usify(promise) {
+  if ("status" in promise) {
+    return promise;
   }
+  const usable = promise;
+  usable.status = "pending";
+  usable.then(
+    (value) => {
+      usable.status = "fulfilled";
+      usable.value = value;
+    },
+    (err) => {
+      usable.status = "rejected";
+      usable.reason = err;
+    }
+  );
+  return usable;
 }
-
-// src/lib/use-polyfill.ts
-var use = (
-  // React.use ||
-  (promise) => {
-    if (promise.status === "pending") {
-      throw promise;
-    } else if (promise.status === "fulfilled") {
-      return promise.value;
-    } else if (promise.status === "rejected") {
-      throw promise.reason;
-    } else {
-      promise.status = "pending";
-      promise.then(
-        (v) => {
-          promise.status = "fulfilled";
-          promise.value = v;
-        },
-        (e) => {
-          promise.status = "rejected";
-          promise.reason = e;
-        }
-      );
-      throw promise;
+var noop = Promise.resolve();
+var ASYNC_LOADING = Object.freeze({ isLoading: true });
+var PaginatedResource = class {
+  constructor(fetchPage) {
+    this._cachedPromise = null;
+    this._paginationState = null;
+    this._fetchPage = fetchPage;
+    this._eventSource = _core.makeEventSource.call(void 0, );
+    this._pendingFetchMore = null;
+    this.observable = this._eventSource.observable;
+    autobind(this);
+  }
+  patchPaginationState(patch) {
+    const state = this._paginationState;
+    if (state === null) return;
+    this._paginationState = { ...state, ...patch };
+    this._eventSource.notify();
+  }
+  async _fetchMore() {
+    const state = this._paginationState;
+    if (!_optionalChain([state, 'optionalAccess', _2 => _2.cursor])) {
+      throw new Error("_fetchMore should not get called while in this state");
+    }
+    this.patchPaginationState({ isFetchingMore: true });
+    try {
+      const nextCursor = await this._fetchPage(state.cursor);
+      this.patchPaginationState({
+        cursor: nextCursor,
+        fetchMoreError: void 0,
+        isFetchingMore: false
+      });
+    } catch (err) {
+      this.patchPaginationState({
+        isFetchingMore: false,
+        fetchMoreError: err
+      });
     }
   }
-);
-
-// src/umbrella-store.ts
-
-
-
-
-
-
-
-
-var ASYNC_LOADING = Object.freeze({ isLoading: true });
-var ASYNC_OK = Object.freeze({ isLoading: false, data: void 0 });
-function makeNotificationSettingsQueryKey(roomId) {
-  return `${roomId}:NOTIFICATION_SETTINGS`;
-}
-function makeVersionsQueryKey(roomId) {
-  return `${roomId}-VERSIONS`;
-}
+  fetchMore() {
+    const state = this._paginationState;
+    if (_optionalChain([state, 'optionalAccess', _3 => _3.cursor]) === null) {
+      return noop;
+    }
+    if (!this._pendingFetchMore) {
+      this._pendingFetchMore = this._fetchMore().finally(() => {
+        this._pendingFetchMore = null;
+      });
+    }
+    return this._pendingFetchMore;
+  }
+  get() {
+    const usable = this._cachedPromise;
+    if (usable === null || usable.status === "pending") {
+      return ASYNC_LOADING;
+    }
+    if (usable.status === "rejected") {
+      return { isLoading: false, error: usable.reason };
+    }
+    const state = this._paginationState;
+    return {
+      isLoading: false,
+      data: {
+        fetchMore: this.fetchMore,
+        isFetchingMore: state.isFetchingMore,
+        fetchMoreError: state.fetchMoreError,
+        hasFetchedAll: state.cursor === null
+      }
+    };
+  }
+  waitUntilLoaded() {
+    if (this._cachedPromise) {
+      return this._cachedPromise;
+    }
+    const initialFetcher = _core.autoRetry.call(void 0, 
+      () => this._fetchPage(
+        /* cursor */
+        void 0
+      ),
+      5,
+      [5e3, 5e3, 1e4, 15e3]
+    );
+    const promise = usify(
+      initialFetcher.then((cursor) => {
+        this._paginationState = {
+          cursor,
+          isFetchingMore: false,
+          fetchMoreError: void 0
+        };
+      })
+    );
+    promise.then(
+      () => this._eventSource.notify(),
+      () => {
+        this._eventSource.notify();
+        setTimeout(() => {
+          this._cachedPromise = null;
+          this._eventSource.notify();
+        }, 5e3);
+      }
+    );
+    this._cachedPromise = promise;
+    return promise;
+  }
+};
 var UmbrellaStore = class {
-  constructor() {
+  constructor(client) {
     this._prevState = null;
     this._stateCached = null;
+    // Notifications
+    this._notificationsLastRequestedAt = null;
+    // Room Threads
+    this._roomThreadsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
+    this._roomThreads = /* @__PURE__ */ new Map();
+    // User Threads
+    this._userThreadsLastRequestedAt = null;
+    this._userThreads = /* @__PURE__ */ new Map();
+    const inboxFetcher = async (cursor) => {
+      if (client === void 0) {
+        throw new (0, _core.StopRetrying)(
+          "Client is required in order to load threads for the room"
+        );
+      }
+      const result = await client.getInboxNotifications({ cursor });
+      this.updateThreadsAndNotifications(
+        result.threads,
+        // TODO: Figure out how to remove this casting
+        result.inboxNotifications
+      );
+      if (this._notificationsLastRequestedAt === null) {
+        this._notificationsLastRequestedAt = result.requestedAt;
+      }
+      const nextCursor = result.nextCursor;
+      return nextCursor;
+    };
+    this._client = client;
+    this._notifications = new PaginatedResource(inboxFetcher);
+    this._notifications.observable.subscribe(
+      () => (
+        // Note that the store itself does not change, but it's only vehicle at
+        // the moment to trigger a re-render, so we'll do a no-op update here.
+        this._store.set((store) => ({ ...store }))
+      )
+    );
     this._store = _core.createStore.call(void 0, {
       rawThreadsById: {},
-      // queries: {},
-      query1: void 0,
-      queries2: {},
       queries3: {},
       queries4: {},
       optimisticUpdates: [],
-      inboxNotificationsById: {},
-      notificationSettingsByRoomId: {},
+      notificationsById: {},
+      settingsByRoomId: {},
       versionsByRoomId: {}
     });
-    this.getFullState = this.getFullState.bind(this);
-    this.getInboxNotificationsAsync = this.getInboxNotificationsAsync.bind(this);
-    this.subscribeThreads = this.subscribeThreads.bind(this);
-    this.subscribeUserThreads = this.subscribeUserThreads.bind(this);
-    this.subscribeThreadsOrInboxNotifications = this.subscribeThreadsOrInboxNotifications.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);
+    autobind(this);
   }
   get() {
     const rawState = this._store.get();
@@ -231,45 +314,79 @@ var UmbrellaStore = class {
     return this.get();
   }
   /**
-   * Returns the async result of the given queryKey. If the query is success,
-   * then it will return the entire store's state in the payload.
+   * Returns the async result of the given query and room id. If the query is success,
+   * then it will return the threads that match that provided query and room id.
+   *
    */
-  // TODO: This return type is a bit weird! Feels like we haven't found the
-  // right abstraction here yet.
-  getThreadsAsync(queryKey) {
-    const internalState = this._store.get();
-    const query = internalState.queries2[queryKey];
-    if (query === void 0 || query.isLoading) {
+  // XXXX Find a better name for that doesn't associate to 'async'
+  getRoomThreadsAsync(roomId, query) {
+    const queryKey = makeRoomThreadsQueryKey(roomId, query);
+    const paginatedResource = this._roomThreads.get(queryKey);
+    if (paginatedResource === void 0) {
       return ASYNC_LOADING;
     }
-    if (query.error) {
-      return query;
+    const asyncResult = paginatedResource.get();
+    if (asyncResult.isLoading || asyncResult.error) {
+      return asyncResult;
     }
-    return { isLoading: false, fullState: this.getFullState() };
+    const threads = selectThreads(this.getFullState(), {
+      roomId,
+      query,
+      orderBy: "age"
+    });
+    const page = asyncResult.data;
+    return {
+      isLoading: false,
+      threads,
+      hasFetchedAll: page.hasFetchedAll,
+      isFetchingMore: page.isFetchingMore,
+      fetchMoreError: page.fetchMoreError,
+      fetchMore: page.fetchMore
+    };
   }
-  getUserThreadsAsync(queryKey) {
-    const internalState = this._store.get();
-    const query = internalState.queries2[queryKey];
-    if (query === void 0 || query.isLoading) {
+  // XXXX - Find a better name for that doesn't associate to 'async'
+  getUserThreadsAsync(query) {
+    const queryKey = makeUserThreadsQueryKey(query);
+    const paginatedResource = this._userThreads.get(queryKey);
+    if (paginatedResource === void 0) {
       return ASYNC_LOADING;
     }
-    if (query.error) {
-      return query;
+    const asyncResult = paginatedResource.get();
+    if (asyncResult.isLoading || asyncResult.error) {
+      return asyncResult;
     }
-    return { isLoading: false, fullState: this.getFullState() };
+    const threads = selectThreads(this.getFullState(), {
+      roomId: null,
+      // Do _not_ filter by roomId
+      query,
+      orderBy: "last-update"
+    });
+    const page = asyncResult.data;
+    return {
+      isLoading: false,
+      threads,
+      hasFetchedAll: page.hasFetchedAll,
+      isFetchingMore: page.isFetchingMore,
+      fetchMoreError: page.fetchMoreError,
+      fetchMore: page.fetchMore
+    };
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
+  // XXXX - Find a better name for that doesn't associate to 'async'
   getInboxNotificationsAsync() {
-    const internalState = this._store.get();
-    const query = internalState.query1;
-    if (query === void 0 || query.isLoading) {
-      return ASYNC_LOADING;
+    const asyncResult = this._notifications.get();
+    if (asyncResult.isLoading || asyncResult.error) {
+      return asyncResult;
     }
-    if (query.error !== void 0) {
-      return query;
-    }
-    const inboxNotifications = this.getFullState().inboxNotifications;
-    return { isLoading: false, inboxNotifications };
+    const page = asyncResult.data;
+    return {
+      isLoading: false,
+      inboxNotifications: this.getFullState().notifications,
+      hasFetchedAll: page.hasFetchedAll,
+      isFetchingMore: page.isFetchingMore,
+      fetchMoreError: page.fetchMoreError,
+      fetchMore: page.fetchMore
+    };
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
   getNotificationSettingsAsync(roomId) {
@@ -283,7 +400,7 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      settings: _core.nn.call(void 0, state.notificationSettingsByRoomId[roomId])
+      settings: _core.nn.call(void 0, state.settingsByRoomId[roomId])
     };
   }
   getVersionsAsync(roomId) {
@@ -339,15 +456,15 @@ var UmbrellaStore = class {
   }
   updateInboxNotificationsCache(mapFn) {
     this._store.set((state) => {
-      const inboxNotifications = mapFn(state.inboxNotificationsById);
-      return inboxNotifications !== state.inboxNotificationsById ? { ...state, inboxNotificationsById: inboxNotifications } : state;
+      const inboxNotifications = mapFn(state.notificationsById);
+      return inboxNotifications !== state.notificationsById ? { ...state, notificationsById: inboxNotifications } : state;
     });
   }
   setNotificationSettings(roomId, settings) {
     this._store.set((state) => ({
       ...state,
-      notificationSettingsByRoomId: {
-        ...state.notificationSettingsByRoomId,
+      settingsByRoomId: {
+        ...state.settingsByRoomId,
         [roomId]: settings
       }
     }));
@@ -361,21 +478,6 @@ var UmbrellaStore = class {
       }
     }));
   }
-  setQuery1State(queryState) {
-    this._store.set((state) => ({
-      ...state,
-      query1: queryState
-    }));
-  }
-  setQuery2State(queryKey, queryState) {
-    this._store.set((state) => ({
-      ...state,
-      queries2: {
-        ...state.queries2,
-        [queryKey]: queryState
-      }
-    }));
-  }
   setQuery3State(queryKey, queryState) {
     this._store.set((state) => ({
       ...state,
@@ -602,7 +704,7 @@ var UmbrellaStore = class {
       }
     });
   }
-  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads, deletedInboxNotifications) {
+  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
     this._store.batch(() => {
       this.updateThreadsCache(
         (cache) => applyThreadUpdates(cache, {
@@ -622,12 +724,14 @@ var UmbrellaStore = class {
    * Updates existing notification setting for a room with a new value,
    * replacing the corresponding optimistic update.
    */
+  // XXXX Rename this helper method
   updateRoomInboxNotificationSettings2(roomId, optimisticUpdateId, settings) {
     this._store.batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
       this.setNotificationSettings(roomId, settings);
     });
   }
+  // XXXX Rename this helper method
   updateRoomInboxNotificationSettings(roomId, settings, queryKey) {
     this._store.batch(() => {
       this.setQuery3OK(queryKey);
@@ -653,29 +757,6 @@ var UmbrellaStore = class {
       (cache) => cache.filter((ou) => ou.id !== optimisticUpdateId)
     );
   }
-  //
-  // Query State APIs
-  //
-  // Query 1
-  setQuery1Loading() {
-    this.setQuery1State(ASYNC_LOADING);
-  }
-  setQuery1OK() {
-    this.setQuery1State(ASYNC_OK);
-  }
-  setQuery1Error(error) {
-    this.setQuery1State({ isLoading: false, error });
-  }
-  // Query 2
-  setQuery2Loading(queryKey) {
-    this.setQuery2State(queryKey, ASYNC_LOADING);
-  }
-  setQuery2OK(queryKey) {
-    this.setQuery2State(queryKey, ASYNC_OK);
-  }
-  setQuery2Error(queryKey, error) {
-    this.setQuery2State(queryKey, { isLoading: false, error });
-  }
   // Query 3
   setQuery3Loading(queryKey) {
     this.setQuery3State(queryKey, ASYNC_LOADING);
@@ -696,12 +777,162 @@ var UmbrellaStore = class {
   setQuery4Error(queryKey, error) {
     this.setQuery4State(queryKey, { isLoading: false, error });
   }
+  async fetchNotificationsDeltaUpdate() {
+    const lastRequestedAt = this._notificationsLastRequestedAt;
+    if (lastRequestedAt === null) {
+      _core.console.warn("Notifications polled before first page loaded");
+      return;
+    }
+    const client = _core.nn.call(void 0, 
+      this._client,
+      "Client is required in order to load notifications for the room"
+    );
+    const result = await client.getInboxNotificationsSince(lastRequestedAt);
+    if (lastRequestedAt < result.requestedAt) {
+      this._notificationsLastRequestedAt = result.requestedAt;
+    }
+    this.updateThreadsAndNotifications(
+      result.threads.updated,
+      result.inboxNotifications.updated,
+      result.threads.deleted,
+      result.inboxNotifications.deleted
+    );
+  }
+  waitUntilNotificationsLoaded() {
+    return this._notifications.waitUntilLoaded();
+  }
+  waitUntilRoomThreadsLoaded(roomId, query) {
+    const threadsFetcher = async (cursor) => {
+      if (this._client === void 0) {
+        throw new (0, _core.StopRetrying)(
+          "Client is required in order to load threads for the room"
+        );
+      }
+      const room = this._client.getRoom(roomId);
+      if (room === null) {
+        throw new (0, _core.StopRetrying)(
+          `Room with id ${roomId} is not available on client`
+        );
+      }
+      const result = await room.getThreads({ cursor, query });
+      this.updateThreadsAndNotifications(
+        result.threads,
+        // TODO: Figure out how to remove this casting
+        result.inboxNotifications
+      );
+      const lastRequestedAt = this._roomThreadsLastRequestedAtByRoom.get(roomId);
+      if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
+        this._roomThreadsLastRequestedAtByRoom.set(roomId, result.requestedAt);
+      }
+      return result.nextCursor;
+    };
+    const queryKey = makeRoomThreadsQueryKey(roomId, query);
+    let paginatedResource = this._roomThreads.get(queryKey);
+    if (paginatedResource === void 0) {
+      paginatedResource = new PaginatedResource(threadsFetcher);
+    }
+    paginatedResource.observable.subscribe(
+      () => (
+        // Note that the store itself does not change, but it's only vehicle at
+        // the moment to trigger a re-render, so we'll do a no-op update here.
+        this._store.set((store) => ({ ...store }))
+      )
+    );
+    this._roomThreads.set(queryKey, paginatedResource);
+    return paginatedResource.waitUntilLoaded();
+  }
+  async fetchRoomThreadsDeltaUpdate(roomId) {
+    const lastRequestedAt = this._roomThreadsLastRequestedAtByRoom.get(roomId);
+    if (lastRequestedAt === void 0) {
+      _core.console.warn("Room threads polled before first page loaded");
+      return;
+    }
+    const client = _core.nn.call(void 0, 
+      this._client,
+      "Client is required in order to load notifications for the room"
+    );
+    const room = _core.nn.call(void 0, 
+      client.getRoom(roomId),
+      `Room with id ${roomId} is not available on client`
+    );
+    const updates = await room.getThreadsSince({
+      since: lastRequestedAt
+    });
+    this.updateThreadsAndNotifications(
+      updates.threads.updated,
+      updates.inboxNotifications.updated,
+      updates.threads.deleted,
+      updates.inboxNotifications.deleted
+    );
+    if (lastRequestedAt < updates.requestedAt) {
+      this._roomThreadsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
+    }
+  }
+  waitUntilUserThreadsLoaded(query) {
+    const queryKey = makeUserThreadsQueryKey(query);
+    const threadsFetcher = async (cursor) => {
+      if (this._client === void 0) {
+        throw new (0, _core.StopRetrying)(
+          "Client is required in order to load threads for the room"
+        );
+      }
+      const result = await this._client[_core.kInternal].getUserThreads_experimental({
+        cursor,
+        query
+      });
+      this.updateThreadsAndNotifications(
+        result.threads,
+        // TODO: Figure out how to remove this casting
+        result.inboxNotifications
+      );
+      if (this._userThreadsLastRequestedAt === null) {
+        this._userThreadsLastRequestedAt = result.requestedAt;
+      }
+      return result.nextCursor;
+    };
+    let paginatedResource = this._userThreads.get(queryKey);
+    if (paginatedResource === void 0) {
+      paginatedResource = new PaginatedResource(threadsFetcher);
+    }
+    paginatedResource.observable.subscribe(
+      () => (
+        // Note that the store itself does not change, but it's only vehicle at
+        // the moment to trigger a re-render, so we'll do a no-op update here.
+        this._store.set((store) => ({ ...store }))
+      )
+    );
+    this._userThreads.set(queryKey, paginatedResource);
+    return paginatedResource.waitUntilLoaded();
+  }
+  async fetchUserThreadsDeltaUpdate() {
+    const lastRequestedAt = this._userThreadsLastRequestedAt;
+    if (lastRequestedAt === null) {
+      _core.console.warn("User threads polled before first page loaded");
+      return;
+    }
+    const client = _core.nn.call(void 0, 
+      this._client,
+      "Client is required in order to load threads for the user"
+    );
+    const result = await client[_core.kInternal].getUserThreadsSince_experimental({
+      since: lastRequestedAt
+    });
+    if (lastRequestedAt < result.requestedAt) {
+      this._notificationsLastRequestedAt = result.requestedAt;
+    }
+    this.updateThreadsAndNotifications(
+      result.threads.updated,
+      result.inboxNotifications.updated,
+      result.threads.deleted,
+      result.inboxNotifications.deleted
+    );
+  }
 };
 function internalToExternalState(state) {
   const computed = {
     threadsById: { ...state.rawThreadsById },
-    inboxNotificationsById: { ...state.inboxNotificationsById },
-    notificationSettingsByRoomId: { ...state.notificationSettingsByRoomId }
+    notificationsById: { ...state.notificationsById },
+    settingsByRoomId: { ...state.settingsByRoomId }
   };
   for (const optimisticUpdate of state.optimisticUpdates) {
     switch (optimisticUpdate.type) {
@@ -768,14 +999,14 @@ function internalToExternalState(state) {
           optimisticUpdate.comment
         );
         const inboxNotification = Object.values(
-          computed.inboxNotificationsById
+          computed.notificationsById
         ).find(
           (notification) => notification.kind === "thread" && notification.threadId === thread.id
         );
         if (inboxNotification === void 0) {
           break;
         }
-        computed.inboxNotificationsById[inboxNotification.id] = {
+        computed.notificationsById[inboxNotification.id] = {
           ...inboxNotification,
           notifiedAt: optimisticUpdate.comment.createdAt,
           readAt: optimisticUpdate.comment.createdAt
@@ -845,20 +1076,23 @@ function internalToExternalState(state) {
         break;
       }
       case "mark-inbox-notification-as-read": {
-        const ibn = computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId];
+        const ibn = computed.notificationsById[optimisticUpdate.inboxNotificationId];
         if (ibn === void 0) {
           break;
         }
-        computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId] = { ...ibn, readAt: optimisticUpdate.readAt };
+        computed.notificationsById[optimisticUpdate.inboxNotificationId] = {
+          ...ibn,
+          readAt: optimisticUpdate.readAt
+        };
         break;
       }
       case "mark-all-inbox-notifications-as-read": {
-        for (const id in computed.inboxNotificationsById) {
-          const ibn = computed.inboxNotificationsById[id];
+        for (const id in computed.notificationsById) {
+          const ibn = computed.notificationsById[id];
           if (ibn === void 0) {
             break;
           }
-          computed.inboxNotificationsById[id] = {
+          computed.notificationsById[id] = {
             ...ibn,
             readAt: optimisticUpdate.readAt
           };
@@ -866,19 +1100,19 @@ function internalToExternalState(state) {
         break;
       }
       case "delete-inbox-notification": {
-        delete computed.inboxNotificationsById[optimisticUpdate.inboxNotificationId];
+        delete computed.notificationsById[optimisticUpdate.inboxNotificationId];
         break;
       }
       case "delete-all-inbox-notifications": {
-        computed.inboxNotificationsById = {};
+        computed.notificationsById = {};
         break;
       }
       case "update-notification-settings": {
-        const settings = computed.notificationSettingsByRoomId[optimisticUpdate.roomId];
+        const settings = computed.settingsByRoomId[optimisticUpdate.roomId];
         if (settings === void 0) {
           break;
         }
-        computed.notificationSettingsByRoomId[optimisticUpdate.roomId] = {
+        computed.settingsByRoomId[optimisticUpdate.roomId] = {
           ...settings,
           ...optimisticUpdate.settings
         };
@@ -896,15 +1130,14 @@ function internalToExternalState(state) {
   );
   const cleanedNotifications = (
     // Sort so that the most recent notifications are first
-    Object.values(computed.inboxNotificationsById).filter(
-      (ibn) => ibn.kind === "thread" ? computed.threadsById[ibn.threadId] && _optionalChain([computed, 'access', _ => _.threadsById, 'access', _2 => _2[ibn.threadId], 'optionalAccess', _3 => _3.deletedAt]) === void 0 : true
+    Object.values(computed.notificationsById).filter(
+      (ibn) => ibn.kind === "thread" ? computed.threadsById[ibn.threadId] && _optionalChain([computed, 'access', _4 => _4.threadsById, 'access', _5 => _5[ibn.threadId], 'optionalAccess', _6 => _6.deletedAt]) === void 0 : true
     ).sort((a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime())
   );
   return {
-    inboxNotifications: cleanedNotifications,
-    inboxNotificationsById: computed.inboxNotificationsById,
-    notificationSettingsByRoomId: computed.notificationSettingsByRoomId,
-    queries2: state.queries2,
+    notifications: cleanedNotifications,
+    notificationsById: computed.notificationsById,
+    settingsByRoomId: computed.settingsByRoomId,
     queries3: state.queries3,
     queries4: state.queries4,
     threads: cleanedThreads,
@@ -978,7 +1211,7 @@ function applyUpsertComment(thread, comment) {
   );
   if (existingComment === void 0) {
     const updatedAt = new Date(
-      Math.max(_optionalChain([thread, 'access', _4 => _4.updatedAt, 'optionalAccess', _5 => _5.getTime, 'call', _6 => _6()]) || 0, comment.createdAt.getTime())
+      Math.max(_optionalChain([thread, 'access', _7 => _7.updatedAt, 'optionalAccess', _8 => _8.getTime, 'call', _9 => _9()]) || 0, comment.createdAt.getTime())
     );
     const updatedThread = {
       ...thread,
@@ -998,8 +1231,8 @@ function applyUpsertComment(thread, comment) {
       ...thread,
       updatedAt: new Date(
         Math.max(
-          _optionalChain([thread, 'access', _7 => _7.updatedAt, 'optionalAccess', _8 => _8.getTime, 'call', _9 => _9()]) || 0,
-          _optionalChain([comment, 'access', _10 => _10.editedAt, 'optionalAccess', _11 => _11.getTime, 'call', _12 => _12()]) || comment.createdAt.getTime()
+          _optionalChain([thread, 'access', _10 => _10.updatedAt, 'optionalAccess', _11 => _11.getTime, 'call', _12 => _12()]) || 0,
+          _optionalChain([comment, 'access', _13 => _13.editedAt, 'optionalAccess', _14 => _14.getTime, 'call', _15 => _15()]) || comment.createdAt.getTime()
         )
       ),
       comments: updatedComments
@@ -1065,7 +1298,7 @@ function applyAddReaction(thread, commentId, reaction) {
   return {
     ...thread,
     updatedAt: new Date(
-      Math.max(reaction.createdAt.getTime(), _optionalChain([thread, 'access', _13 => _13.updatedAt, 'optionalAccess', _14 => _14.getTime, 'call', _15 => _15()]) || 0)
+      Math.max(reaction.createdAt.getTime(), _optionalChain([thread, 'access', _16 => _16.updatedAt, 'optionalAccess', _17 => _17.getTime, 'call', _18 => _18()]) || 0)
     ),
     comments: updatedComments
   };
@@ -1098,7 +1331,7 @@ function applyRemoveReaction(thread, commentId, emoji, userId, removedAt) {
   return {
     ...thread,
     updatedAt: new Date(
-      Math.max(removedAt.getTime(), _optionalChain([thread, 'access', _16 => _16.updatedAt, 'optionalAccess', _17 => _17.getTime, 'call', _18 => _18()]) || 0)
+      Math.max(removedAt.getTime(), _optionalChain([thread, 'access', _19 => _19.updatedAt, 'optionalAccess', _20 => _20.getTime, 'call', _21 => _21()]) || 0)
     ),
     comments: updatedComments
   };
@@ -1125,9 +1358,100 @@ function upsertReaction(reactions, reaction) {
       } : existingReaction2
     );
   }
-  return reactions;
+  return reactions;
+}
+
+// src/liveblocks.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _indexjs = require('use-sync-external-store/shim/index.js');
+var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');
+
+// src/lib/shallow2.ts
+
+function shallow2(a, b) {
+  if (!_core.isPlainObject.call(void 0, a) || !_core.isPlainObject.call(void 0, b)) {
+    return _core.shallow.call(void 0, 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) && _core.shallow.call(void 0, a[key], b[key])
+  );
+}
+
+// src/lib/use-initial.ts
+
+
+// src/lib/use-latest.ts
+
+function useLatest(value) {
+  const ref = _react.useRef.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// src/lib/use-initial.ts
+var noop2 = (state) => state;
+function useInitial(value) {
+  return _react.useReducer.call(void 0, noop2, value)[0];
+}
+function useInitialUnlessFunction(latestValue) {
+  const frozenValue = useInitial(latestValue);
+  if (typeof frozenValue === "function") {
+    const ref = useLatest(latestValue);
+    return _react.useCallback.call(void 0, (...args) => ref.current(...args), [
+      ref
+    ]);
+  } else {
+    return frozenValue;
+  }
 }
 
+// src/lib/use-polyfill.ts
+var use = (
+  // React.use ||
+  (promise) => {
+    if (promise.status === "pending") {
+      throw promise;
+    } else if (promise.status === "fulfilled") {
+      return promise.value;
+    } else if (promise.status === "rejected") {
+      throw promise.reason;
+    } else {
+      promise.status = "pending";
+      promise.then(
+        (v) => {
+          promise.status = "fulfilled";
+          promise.value = v;
+        },
+        (e) => {
+          promise.status = "rejected";
+          promise.reason = e;
+        }
+      );
+      throw promise;
+    }
+  }
+);
+
 // src/liveblocks.tsx
 var ClientContext = _react.createContext.call(void 0, null);
 function missingUserError(userId) {
@@ -1145,7 +1469,6 @@ var _umbrellaStores = /* @__PURE__ */ new WeakMap();
 var _extras = /* @__PURE__ */ new WeakMap();
 var _bundles = /* @__PURE__ */ new WeakMap();
 var POLLING_INTERVAL = 60 * 1e3;
-var USER_THREADS_QUERY = "USER_THREADS";
 function selectUnreadInboxNotificationsCount(inboxNotifications) {
   let count = 0;
   for (const notification of inboxNotifications) {
@@ -1165,7 +1488,7 @@ function selectorFor_useUnreadInboxNotificationsCount(result) {
   };
 }
 function selectorFor_useUser(state, userId) {
-  if (state === void 0 || _optionalChain([state, 'optionalAccess', _19 => _19.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _22 => _22.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -1183,7 +1506,7 @@ function selectorFor_useUser(state, userId) {
   };
 }
 function selectorFor_useRoomInfo(state, roomId) {
-  if (state === void 0 || _optionalChain([state, 'optionalAccess', _20 => _20.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _23 => _23.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -1200,19 +1523,6 @@ function selectorFor_useRoomInfo(state, roomId) {
     info: state.data
   };
 }
-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) {
   let bundle = _bundles.get(client);
   if (!bundle) {
@@ -1224,187 +1534,74 @@ function getOrCreateContextBundle(client) {
 function getUmbrellaStoreForClient(client) {
   let store = _umbrellaStores.get(client);
   if (!store) {
-    store = new UmbrellaStore();
+    store = new UmbrellaStore(client);
     _umbrellaStores.set(client, store);
   }
   return store;
 }
-function getExtrasForClient(client) {
+function getLiveblocksExtrasForClient(client) {
   let extras = _extras.get(client);
   if (!extras) {
-    extras = makeExtrasForClient(client);
+    extras = makeLiveblocksExtrasForClient(client);
     _extras.set(client, extras);
   }
   return extras;
 }
-function makeExtrasForClient(client) {
-  const store = getUmbrellaStoreForClient(client);
-  let lastRequestedAt;
-  async function fetchInboxNotifications() {
-    if (lastRequestedAt === void 0) {
-      const result = await client.getInboxNotifications();
-      store.batch(() => {
-        store.updateThreadsAndNotifications(
-          result.threads,
-          result.inboxNotifications,
-          [],
-          []
-        );
-        store.setQuery1OK();
-      });
-      lastRequestedAt = result.requestedAt;
-    } else {
-      const result = await client.getInboxNotificationsSince({
-        since: lastRequestedAt
-      });
-      store.batch(() => {
-        store.updateThreadsAndNotifications(
-          result.threads.updated,
-          result.inboxNotifications.updated,
-          result.threads.deleted,
-          result.inboxNotifications.deleted
-        );
-        store.setQuery1OK();
-      });
-      if (lastRequestedAt < result.requestedAt) {
-        lastRequestedAt = result.requestedAt;
-      }
-    }
-  }
-  let pollerSubscribers = 0;
+function makeDeltaPoller_Notifications(store) {
   const poller = _core.makePoller.call(void 0, async () => {
     try {
-      await waitUntilInboxNotificationsLoaded();
-      await fetchInboxNotifications();
+      await store.waitUntilNotificationsLoaded();
+      await store.fetchNotificationsDeltaUpdate();
     } catch (err) {
       console.warn(`Polling new inbox notifications failed: ${String(err)}`);
     }
-  });
-  const waitUntilInboxNotificationsLoaded = _core.memoizeOnSuccess.call(void 0, async () => {
-    store.setQuery1Loading();
-    try {
-      await _core.autoRetry.call(void 0, 
-        () => fetchInboxNotifications(),
-        5,
-        [5e3, 5e3, 1e4, 15e3]
-      );
-    } catch (err) {
-      store.setQuery1Error(err);
-      throw err;
-    }
-  });
-  function loadInboxNotifications() {
-    void waitUntilInboxNotificationsLoaded().catch(() => {
-    });
-  }
-  function startPolling() {
+  }, POLLING_INTERVAL);
+  let pollerSubscribers = 0;
+  return () => {
     pollerSubscribers++;
-    poller.start(POLLING_INTERVAL);
+    poller.enable(pollerSubscribers > 0);
     return () => {
-      if (pollerSubscribers <= 0) {
-        console.warn(
-          "Unexpected internal error: cannot decrease subscriber count for inbox notifications."
-        );
-        return;
-      }
       pollerSubscribers--;
-      if (pollerSubscribers <= 0) {
-        poller.stop();
-      }
+      poller.enable(pollerSubscribers > 0);
     };
-  }
-  const userThreadsPoller = _core.makePoller.call(void 0, refreshUserThreads);
-  let isFetchingUserThreadsUpdates = false;
-  async function refreshUserThreads() {
-    const since = userThreadslastRequestedAt;
-    if (since === void 0 || isFetchingUserThreadsUpdates) {
-      return;
-    }
+  };
+}
+function makeDeltaPoller_UserThreads(store) {
+  const poller = _core.makePoller.call(void 0, async () => {
     try {
-      isFetchingUserThreadsUpdates = true;
-      const updates = await client[_core.kInternal].getThreadsSince({
-        since
-      });
-      isFetchingUserThreadsUpdates = false;
-      store.batch(() => {
-        store.updateThreadsAndNotifications(
-          updates.threads.updated,
-          [],
-          updates.threads.deleted,
-          []
-        );
-        store.setQuery2OK(USER_THREADS_QUERY);
-      });
-      userThreadslastRequestedAt = updates.requestedAt;
+      await store.fetchUserThreadsDeltaUpdate();
     } catch (err) {
-      isFetchingUserThreadsUpdates = false;
-      return;
+      console.warn(`Polling new user threads failed: ${String(err)}`);
     }
-  }
-  const userThreadsSubscribersByQuery = /* @__PURE__ */ new Map();
-  const userThreadsRequestsByQuery = /* @__PURE__ */ new Map();
-  function incrementUserThreadsQuerySubscribers(queryKey) {
-    const subscribers = _nullishCoalesce(userThreadsSubscribersByQuery.get(queryKey), () => ( 0));
-    userThreadsSubscribersByQuery.set(queryKey, subscribers + 1);
-    userThreadsPoller.start(POLLING_INTERVAL);
+  }, POLLING_INTERVAL);
+  let pollerSubscribers = 0;
+  return () => {
+    pollerSubscribers++;
+    poller.enable(pollerSubscribers > 0);
     return () => {
-      const subscribers2 = userThreadsSubscribersByQuery.get(queryKey);
-      if (subscribers2 === void 0 || subscribers2 <= 0) {
-        console.warn(
-          `Internal unexpected behavior. Cannot decrease subscriber count for query "${queryKey}"`
-        );
-        return;
-      }
-      userThreadsSubscribersByQuery.set(queryKey, subscribers2 - 1);
-      let totalSubscribers = 0;
-      for (const subscribers3 of userThreadsSubscribersByQuery.values()) {
-        totalSubscribers += subscribers3;
-      }
-      if (totalSubscribers <= 0) {
-        userThreadsPoller.stop();
-      }
+      pollerSubscribers--;
+      poller.enable(pollerSubscribers > 0);
     };
-  }
-  let userThreadslastRequestedAt;
-  async function getUserThreads(queryKey, options, { retryCount } = { retryCount: 0 }) {
-    const existingRequest = userThreadsRequestsByQuery.get(queryKey);
-    if (existingRequest !== void 0) return existingRequest;
-    const request = client[_core.kInternal].getThreads(options);
-    userThreadsRequestsByQuery.set(queryKey, request);
-    store.setQuery2Loading(queryKey);
-    try {
-      const result = await request;
-      store.batch(() => {
-        store.updateThreadsAndNotifications(
-          result.threads,
-          result.inboxNotifications,
-          [],
-          []
-        );
-        store.setQuery2OK(queryKey);
-      });
-      if (userThreadslastRequestedAt === void 0 || userThreadslastRequestedAt < result.requestedAt) {
-        userThreadslastRequestedAt = result.requestedAt;
-      }
-      userThreadsPoller.start(POLLING_INTERVAL);
-    } catch (err) {
-      userThreadsRequestsByQuery.delete(queryKey);
-      retryError(() => {
-        void getUserThreads(queryKey, options, {
-          retryCount: retryCount + 1
-        });
-      }, retryCount);
-      store.setQuery2Error(queryKey, err);
-    }
-    return;
-  }
+  };
+}
+function makeLiveblocksExtrasForClient(client) {
+  const store = getUmbrellaStoreForClient(client);
   return {
     store,
-    startPolling,
-    waitUntilInboxNotificationsLoaded,
-    loadInboxNotifications,
-    incrementUserThreadsQuerySubscribers,
-    getUserThreads
+    /**
+     * Sub/unsub pair to start the process of watching for new incoming inbox
+     * notifications through a stream of delta updates. Call the unsub function
+     * returned to stop this subscription when unmounting. Currently
+     * implemented by a periodic poller.
+     */
+    subscribeToNotificationsDeltaUpdates: makeDeltaPoller_Notifications(store),
+    /**
+     * Sub/unsub pair to start the process of watching for new user threads
+     * through a stream of delta updates. Call the unsub function returned to
+     * stop this subscription when unmounting. Currently implemented by
+     * a periodic poller.
+     */
+    subscribeToUserThreadsDeltaUpdates: makeDeltaPoller_UserThreads(store)
   };
 }
 function makeLiveblocksContextBundle(client) {
@@ -1420,7 +1617,7 @@ function makeLiveblocksContextBundle(client) {
   const shared = createSharedContext(client);
   const bundle = {
     LiveblocksProvider: LiveblocksProvider2,
-    useInboxNotifications: () => useInboxNotifications_withClient(client),
+    useInboxNotifications: () => useInboxNotifications_withClient(client, identity, _core.shallow),
     useUnreadInboxNotificationsCount: () => useUnreadInboxNotificationsCount_withClient(client),
     useMarkInboxNotificationAsRead: useMarkInboxNotificationAsRead2,
     useMarkAllInboxNotificationsAsRead: useMarkAllInboxNotificationsAsRead2,
@@ -1444,41 +1641,42 @@ function makeLiveblocksContextBundle(client) {
   };
   return bundle;
 }
-function useInboxNotifications_withClient(client) {
-  const { loadInboxNotifications, store, startPolling } = getExtrasForClient(client);
-  _react.useEffect.call(void 0, loadInboxNotifications, [loadInboxNotifications]);
-  _react.useEffect.call(void 0, startPolling, [startPolling]);
+function useInboxNotifications_withClient(client, selector, isEqual) {
+  const {
+    store,
+    subscribeToNotificationsDeltaUpdates: subscribeToDeltaUpdates
+  } = getLiveblocksExtrasForClient(client);
+  _react.useEffect.call(void 0, () => {
+    void store.waitUntilNotificationsLoaded().catch(() => {
+    });
+  });
+  _react.useEffect.call(void 0, subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
   return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
     store.subscribeThreadsOrInboxNotifications,
     store.getInboxNotificationsAsync,
     store.getInboxNotificationsAsync,
-    identity,
-    _core.shallow
+    selector,
+    isEqual
   );
 }
 function useInboxNotificationsSuspense_withClient(client) {
-  const { waitUntilInboxNotificationsLoaded } = getExtrasForClient(client);
-  use(waitUntilInboxNotificationsLoaded());
-  const result = useInboxNotifications_withClient(client);
+  const store = getLiveblocksExtrasForClient(client).store;
+  use(store.waitUntilNotificationsLoaded());
+  const result = useInboxNotifications_withClient(client, identity, _core.shallow);
   _core.assert.call(void 0, !result.error, "Did not expect error");
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   return result;
 }
 function useUnreadInboxNotificationsCount_withClient(client) {
-  const { store, loadInboxNotifications, startPolling } = getExtrasForClient(client);
-  _react.useEffect.call(void 0, loadInboxNotifications, [loadInboxNotifications]);
-  _react.useEffect.call(void 0, startPolling, [startPolling]);
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribeThreadsOrInboxNotifications,
-    store.getInboxNotificationsAsync,
-    store.getInboxNotificationsAsync,
+  return useInboxNotifications_withClient(
+    client,
     selectorFor_useUnreadInboxNotificationsCount,
     _core.shallow
   );
 }
 function useUnreadInboxNotificationsCountSuspense_withClient(client) {
-  const { waitUntilInboxNotificationsLoaded } = getExtrasForClient(client);
-  use(waitUntilInboxNotificationsLoaded());
+  const store = getLiveblocksExtrasForClient(client).store;
+  use(store.waitUntilNotificationsLoaded());
   const result = useUnreadInboxNotificationsCount_withClient(client);
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   _core.assert.call(void 0, !result.error, "Did not expect error");
@@ -1487,7 +1685,7 @@ function useUnreadInboxNotificationsCountSuspense_withClient(client) {
 function useMarkInboxNotificationAsRead_withClient(client) {
   return _react.useCallback.call(void 0, 
     (inboxNotificationId) => {
-      const { store } = getExtrasForClient(client);
+      const { store } = getLiveblocksExtrasForClient(client);
       const readAt = /* @__PURE__ */ new Date();
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "mark-inbox-notification-as-read",
@@ -1512,7 +1710,7 @@ function useMarkInboxNotificationAsRead_withClient(client) {
 }
 function useMarkAllInboxNotificationsAsRead_withClient(client) {
   return _react.useCallback.call(void 0, () => {
-    const { store } = getExtrasForClient(client);
+    const { store } = getLiveblocksExtrasForClient(client);
     const readAt = /* @__PURE__ */ new Date();
     const optimisticUpdateId = store.addOptimisticUpdate({
       type: "mark-all-inbox-notifications-as-read",
@@ -1534,7 +1732,7 @@ function useMarkAllInboxNotificationsAsRead_withClient(client) {
 function useDeleteInboxNotification_withClient(client) {
   return _react.useCallback.call(void 0, 
     (inboxNotificationId) => {
-      const { store } = getExtrasForClient(client);
+      const { store } = getLiveblocksExtrasForClient(client);
       const deletedAt = /* @__PURE__ */ new Date();
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "delete-inbox-notification",
@@ -1558,7 +1756,7 @@ function useDeleteInboxNotification_withClient(client) {
 }
 function useDeleteAllInboxNotifications_withClient(client) {
   return _react.useCallback.call(void 0, () => {
-    const { store } = getExtrasForClient(client);
+    const { store } = getLiveblocksExtrasForClient(client);
     const deletedAt = /* @__PURE__ */ new Date();
     const optimisticUpdateId = store.addOptimisticUpdate({
       type: "delete-all-inbox-notifications",
@@ -1575,11 +1773,11 @@ function useDeleteAllInboxNotifications_withClient(client) {
   }, [client]);
 }
 function useInboxNotificationThread_withClient(client, inboxNotificationId) {
-  const { store } = getExtrasForClient(client);
+  const { store } = getLiveblocksExtrasForClient(client);
   const getter = store.getFullState;
   const selector = _react.useCallback.call(void 0, 
     (state) => {
-      const inboxNotification = _nullishCoalesce(state.inboxNotificationsById[inboxNotificationId], () => ( _core.raise.call(void 0, `Inbox notification with ID "${inboxNotificationId}" not found`)));
+      const inboxNotification = _nullishCoalesce(state.notificationsById[inboxNotificationId], () => ( _core.raise.call(void 0, `Inbox notification with ID "${inboxNotificationId}" not found`)));
       if (inboxNotification.kind !== "thread") {
         _core.raise.call(void 0, 
           `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
@@ -1722,7 +1920,7 @@ function createSharedContext(client) {
 }
 function useEnsureNoLiveblocksProvider(options) {
   const existing = useClientOrNull();
-  if (!_optionalChain([options, 'optionalAccess', _21 => _21.allowNesting]) && existing !== null) {
+  if (!_optionalChain([options, 'optionalAccess', _24 => _24.allowNesting]) && existing !== null) {
     throw new Error(
       "You cannot nest multiple LiveblocksProvider instances in the same React tree."
     );
@@ -1774,40 +1972,32 @@ function useUserThreads_experimental(options = {
     metadata: {}
   }
 }) {
-  const queryKey = React.default.useMemo(
-    () => makeUserThreadsQueryKey(options.query),
-    [options]
-  );
   const client = useClient();
-  const { store, incrementUserThreadsQuerySubscribers, getUserThreads } = getExtrasForClient(client);
-  _react.useEffect.call(void 0, () => {
-    void getUserThreads(queryKey, options);
-    return incrementUserThreadsQuerySubscribers(queryKey);
-  }, [queryKey, incrementUserThreadsQuerySubscribers, getUserThreads, options]);
-  const getter = _react.useCallback.call(void 0, 
-    () => store.getUserThreadsAsync(queryKey),
-    [store, queryKey]
-  );
-  const selector = _react.useCallback.call(void 0, 
-    (result) => {
-      if (!result.fullState) {
-        return result;
-      }
-      const threads = selectThreads(result.fullState, {
-        roomId: null,
-        // Do _not_ filter by roomId
-        query: options.query,
-        orderBy: "last-update"
+  const { store, subscribeToUserThreadsDeltaUpdates: subscribeToDeltaUpdates } = getLiveblocksExtrasForClient(client);
+  _react.useEffect.call(void 0, 
+    () => {
+      void store.waitUntilUserThreadsLoaded(options.query).catch(() => {
       });
-      return { isLoading: false, threads };
-    },
-    [options]
+    }
+    // NOTE: Deliberately *not* using a dependency array here!
+    //
+    // It is important to call waitUntil on *every* render.
+    // This is harmless though, on most renders, except:
+    // 1. The very first render, in which case we'll want to trigger the initial page fetch.
+    // 2. All other subsequent renders now "just" return the same promise (a quick operation).
+    // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
+    //    *next* render after that, a *new* fetch/promise will get created.
+  );
+  _react.useEffect.call(void 0, subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  const getter = _react.useCallback.call(void 0, 
+    () => store.getUserThreadsAsync(options.query),
+    [store, options.query]
   );
   return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
     store.subscribeUserThreads,
     getter,
     getter,
-    selector,
+    identity,
     shallow2
     // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
   );
@@ -1817,49 +2007,16 @@ function useUserThreadsSuspense_experimental(options = {
     metadata: {}
   }
 }) {
-  const queryKey = React.default.useMemo(
-    () => makeUserThreadsQueryKey(options.query),
-    [options]
-  );
   const client = useClient();
-  const { store, getUserThreads } = getExtrasForClient(client);
-  React.default.useEffect(() => {
-    const { incrementUserThreadsQuerySubscribers } = getExtrasForClient(client);
-    return incrementUserThreadsQuerySubscribers(queryKey);
-  }, [client, queryKey]);
-  const query = store.getFullState().queries2[queryKey];
-  if (query === void 0 || query.isLoading) {
-    throw getUserThreads(queryKey, options);
-  }
-  if (query.error) {
-    throw query.error;
-  }
-  const getter = store.getFullState;
-  const selector = _react.useCallback.call(void 0, 
-    (state) => {
-      return {
-        threads: selectThreads(state, {
-          roomId: null,
-          // Do _not_ filter by roomId
-          query: options.query,
-          orderBy: "last-update"
-        }),
-        isLoading: false
-      };
-    },
-    [options]
-  );
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribeUserThreads,
-    getter,
-    getter,
-    selector,
-    shallow2
-    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
-  );
+  const { store } = getLiveblocksExtrasForClient(client);
+  use(store.waitUntilUserThreadsLoaded(options.query));
+  const result = useUserThreads_experimental(options);
+  _core.assert.call(void 0, !result.error, "Did not expect error");
+  _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
+  return result;
 }
 function useInboxNotifications() {
-  return useInboxNotifications_withClient(useClient());
+  return useInboxNotifications_withClient(useClient(), identity, _core.shallow);
 }
 function useInboxNotificationsSuspense() {
   return useInboxNotificationsSuspense_withClient(useClient());
@@ -1907,7 +2064,6 @@ var _useUser = useUser;
 var _useUserSuspense = useUserSuspense;
 var _useUserThreads_experimental = useUserThreads_experimental;
 var _useUserThreadsSuspense_experimental = useUserThreadsSuspense_experimental;
-var makeUserThreadsQueryKey = (options) => `${USER_THREADS_QUERY}:${_core.stringify.call(void 0, options)}`;
 
 // src/types/errors.ts
 var CreateThreadError = class extends Error {
@@ -2008,7 +2164,7 @@ var UpdateNotificationSettingsError = class extends Error {
 };
 
 // src/room.tsx
-var _client = require('@liveblocks/client');
+var _client2 = require('@liveblocks/client');
 
 
 
@@ -2026,6 +2182,16 @@ var _client = require('@liveblocks/client');
 
 
 
+// src/lib/retry-error.ts
+var MAX_ERROR_RETRY_COUNT = 5;
+var ERROR_RETRY_INTERVAL = 5e3;
+function retryError(action, retryCount) {
+  if (retryCount >= MAX_ERROR_RETRY_COUNT) return;
+  const timeout = Math.pow(2, retryCount) * ERROR_RETRY_INTERVAL;
+  setTimeout(() => {
+    void action();
+  }, timeout);
+}
 
 // src/use-scroll-to-comment-on-load-effect.ts
 
@@ -2058,7 +2224,7 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 
 // src/room.tsx
 var SMOOTH_DELAY = 1e3;
-var noop2 = () => {
+var noop3 = () => {
 };
 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:
@@ -2126,12 +2292,34 @@ function getCurrentUserId(room) {
 }
 function handleApiError(err) {
   const message = `Request failed with status ${err.status}: ${err.message}`;
-  if (_optionalChain([err, 'access', _22 => _22.details, 'optionalAccess', _23 => _23.error]) === "FORBIDDEN") {
+  if (_optionalChain([err, 'access', _25 => _25.details, 'optionalAccess', _26 => _26.error]) === "FORBIDDEN") {
     const detailedMessage = [message, err.details.suggestion, err.details.docs].filter(Boolean).join("\n");
     _core.console.error(detailedMessage);
   }
   return new Error(message);
 }
+function makeDeltaPoller_RoomThreads(client) {
+  const store = getUmbrellaStoreForClient(client);
+  const poller = _core.makePoller.call(void 0, async () => {
+    const roomIds = client[_core.kInternal].getRoomIds();
+    await Promise.allSettled(
+      roomIds.map((roomId) => {
+        const room = client.getRoom(roomId);
+        if (room === null) return;
+        return store.fetchRoomThreadsDeltaUpdate(room.id);
+      })
+    );
+  }, POLLING_INTERVAL2);
+  let pollerSubscribers = 0;
+  return () => {
+    pollerSubscribers++;
+    poller.enable(pollerSubscribers > 0);
+    return () => {
+      pollerSubscribers--;
+      poller.enable(pollerSubscribers > 0);
+    };
+  };
+}
 var _extras2 = /* @__PURE__ */ new WeakMap();
 var _bundles2 = /* @__PURE__ */ new WeakMap();
 function getOrCreateRoomContextBundle(client) {
@@ -2142,78 +2330,17 @@ function getOrCreateRoomContextBundle(client) {
   }
   return bundle;
 }
-function getExtrasForClient2(client) {
+function getRoomExtrasForClient(client) {
   let extras = _extras2.get(client);
   if (!extras) {
-    extras = makeExtrasForClient2(client);
+    extras = makeRoomExtrasForClient(client);
     _extras2.set(client, extras);
   }
   return extras;
 }
-function makeExtrasForClient2(client) {
+function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
-  const DEFAULT_DEDUPING_INTERVAL = 2e3;
-  const lastRequestedAtByRoom = /* @__PURE__ */ new Map();
   const requestsByQuery = /* @__PURE__ */ new Map();
-  const requestStatusByRoom = /* @__PURE__ */ new Map();
-  const subscribersByQuery = /* @__PURE__ */ new Map();
-  const poller = _core.makePoller.call(void 0, refreshThreadsAndNotifications);
-  async function refreshThreadsAndNotifications() {
-    const requests = [];
-    client[_core.kInternal].getRoomIds().map((roomId) => {
-      const room = client.getRoom(roomId);
-      if (room === null) return;
-      requests.push(getThreadsUpdates(room.id));
-    });
-    await Promise.allSettled(requests);
-  }
-  function incrementQuerySubscribers(queryKey) {
-    const subscribers = _nullishCoalesce(subscribersByQuery.get(queryKey), () => ( 0));
-    subscribersByQuery.set(queryKey, subscribers + 1);
-    poller.start(POLLING_INTERVAL2);
-    return () => {
-      const subscribers2 = subscribersByQuery.get(queryKey);
-      if (subscribers2 === void 0 || subscribers2 <= 0) {
-        _core.console.warn(
-          `Internal unexpected behavior. Cannot decrease subscriber count for query "${queryKey}"`
-        );
-        return;
-      }
-      subscribersByQuery.set(queryKey, subscribers2 - 1);
-      let totalSubscribers = 0;
-      for (const subscribers3 of subscribersByQuery.values()) {
-        totalSubscribers += subscribers3;
-      }
-      if (totalSubscribers <= 0) {
-        poller.stop();
-      }
-    };
-  }
-  async function getThreadsUpdates(roomId) {
-    const room = client.getRoom(roomId);
-    if (room === null) return;
-    const since = lastRequestedAtByRoom.get(room.id);
-    if (since === void 0) return;
-    const isFetchingThreadsUpdates = _nullishCoalesce(requestStatusByRoom.get(room.id), () => ( false));
-    if (isFetchingThreadsUpdates === true) return;
-    try {
-      requestStatusByRoom.set(room.id, true);
-      const updates = await room.getThreadsSince({ since });
-      setTimeout(() => {
-        requestStatusByRoom.set(room.id, false);
-      }, DEFAULT_DEDUPING_INTERVAL);
-      store.updateThreadsAndNotifications(
-        updates.threads.updated,
-        updates.inboxNotifications.updated,
-        updates.threads.deleted,
-        updates.inboxNotifications.deleted
-      );
-      lastRequestedAtByRoom.set(room.id, updates.requestedAt);
-    } catch (err) {
-      requestStatusByRoom.set(room.id, false);
-      return;
-    }
-  }
   async function getRoomVersions(room, { retryCount } = { retryCount: 0 }) {
     const queryKey = makeVersionsQueryKey(room.id);
     const existingRequest = requestsByQuery.get(queryKey);
@@ -2243,40 +2370,6 @@ function makeExtrasForClient2(client) {
     }
     return;
   }
-  async function getThreadsAndInboxNotifications(room, queryKey, options, { retryCount } = { retryCount: 0 }) {
-    const existingRequest = requestsByQuery.get(queryKey);
-    if (existingRequest !== void 0) return existingRequest;
-    const request = room.getThreads(options);
-    requestsByQuery.set(queryKey, request);
-    store.setQuery2Loading(queryKey);
-    try {
-      const result = await request;
-      store.batch(() => {
-        store.updateThreadsAndNotifications(
-          result.threads,
-          // TODO: Figure out how to remove this casting
-          result.inboxNotifications,
-          [],
-          []
-        );
-        store.setQuery2OK(queryKey);
-      });
-      const lastRequestedAt = lastRequestedAtByRoom.get(room.id);
-      if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
-        lastRequestedAtByRoom.set(room.id, result.requestedAt);
-      }
-      poller.start(POLLING_INTERVAL2);
-    } catch (err) {
-      requestsByQuery.delete(queryKey);
-      retryError(() => {
-        void getThreadsAndInboxNotifications(room, queryKey, options, {
-          retryCount: retryCount + 1
-        });
-      }, retryCount);
-      store.setQuery2Error(queryKey, err);
-    }
-    return;
-  }
   async function getInboxNotificationSettings(room, { retryCount } = { retryCount: 0 }) {
     const queryKey = makeNotificationSettingsQueryKey(room.id);
     const existingRequest = requestsByQuery.get(queryKey);
@@ -2314,10 +2407,8 @@ function makeExtrasForClient2(client) {
   }
   return {
     store,
-    incrementQuerySubscribers,
+    subscribeToRoomThreadsDeltaUpdates: makeDeltaPoller_RoomThreads(client),
     commentsErrorEventSource,
-    getThreadsUpdates,
-    getThreadsAndInboxNotifications,
     getInboxNotificationSettings,
     getRoomVersions,
     onMutationFailure
@@ -2492,7 +2583,7 @@ function RoomProviderInner(props) {
     })
   );
   React5.useEffect(() => {
-    const { store } = getExtrasForClient2(client);
+    const { store } = getRoomExtrasForClient(client);
     async function handleCommentEvent(message) {
       if (message.type === _core.ServerMsgCode.THREAD_DELETED) {
         store.deleteThread(message.threadId, null);
@@ -2527,13 +2618,15 @@ function RoomProviderInner(props) {
     );
   }, [client, room]);
   React5.useEffect(() => {
-    const { getThreadsUpdates } = getExtrasForClient2(client);
-    void getThreadsUpdates(room.id);
+    const store = getRoomExtrasForClient(client).store;
+    void store.fetchRoomThreadsDeltaUpdate(room.id).catch(() => {
+    });
   }, [client, room.id]);
   React5.useEffect(() => {
     function handleIsOnline() {
-      const { getThreadsUpdates } = getExtrasForClient2(client);
-      void getThreadsUpdates(room.id);
+      const store = getRoomExtrasForClient(client).store;
+      void store.fetchRoomThreadsDeltaUpdate(room.id).catch(() => {
+      });
     }
     window.addEventListener("online", handleIsOnline);
     return () => {
@@ -2568,7 +2661,7 @@ function useStatus() {
   return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
 }
 function useStorageStatus(options) {
-  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.smooth]), () => ( false)));
+  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _27 => _27.smooth]), () => ( false)));
   if (smooth) {
     return useStorageStatusSmooth();
   } else {
@@ -2732,7 +2825,7 @@ function useOthersMapped(itemSelector, itemIsEqual) {
   return useOthers(wrappedSelector, wrappedIsEqual);
 }
 function useOthersConnectionIds() {
-  return useOthers(selectorFor_useOthersConnectionIds, _client.shallow);
+  return useOthers(selectorFor_useOthersConnectionIds, _client2.shallow);
 }
 var NOT_FOUND = Symbol();
 function useOther(connectionId, selector, isEqual) {
@@ -2779,7 +2872,7 @@ function useStorage(selector, isEqual) {
     [selector]
   );
   const subscribe = React5.useCallback(
-    (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop2,
+    (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop3,
     [room, rootOrNull]
   );
   const getSnapshot = React5.useCallback(() => {
@@ -2827,40 +2920,33 @@ function useThreads(options = {
   const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
-  const queryKey = React5.useMemo(
-    () => generateQueryKey(room.id, options.query),
-    [room, options]
-  );
-  const { store, getThreadsAndInboxNotifications, incrementQuerySubscribers } = getExtrasForClient2(client);
-  React5.useEffect(() => {
-    void getThreadsAndInboxNotifications(room, queryKey, options);
-    return incrementQuerySubscribers(queryKey);
-  }, [room, queryKey]);
-  const getter = React5.useCallback(
-    () => store.getThreadsAsync(queryKey),
-    [store, queryKey]
-  );
-  const selector = React5.useCallback(
-    (result) => {
-      if (!result.fullState) {
-        return result;
-      }
-      const threads = selectThreads(result.fullState, {
-        roomId: room.id,
-        query: options.query,
-        orderBy: "age"
+  const { store, subscribeToRoomThreadsDeltaUpdates: subscribeToDeltaUpdates } = getRoomExtrasForClient(client);
+  React5.useEffect(
+    () => {
+      void store.waitUntilRoomThreadsLoaded(room.id, options.query).catch(() => {
       });
-      return { isLoading: false, threads };
-    },
-    [room.id, queryKey]
-    // eslint-disable-line react-hooks/exhaustive-deps
+    }
+    // NOTE: Deliberately *not* using a dependency array here!
+    //
+    // It is important to call waitUntil on *every* render.
+    // This is harmless though, on most renders, except:
+    // 1. The very first render, in which case we'll want to trigger the initial page fetch.
+    // 2. All other subsequent renders now "just" return the same promise (a quick operation).
+    // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
+    //    *next* render after that, a *new* fetch/promise will get created.
+  );
+  React5.useEffect(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  const getter = React5.useCallback(
+    () => store.getRoomThreadsAsync(room.id, options.query),
+    [store, room.id, options.query]
   );
   const state = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
     store.subscribeThreads,
     getter,
     getter,
-    selector,
+    identity2,
     shallow2
+    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
   );
   useScrollToCommentOnLoadEffect(scrollOnLoad, state);
   return state;
@@ -2868,7 +2954,7 @@ function useThreads(options = {
 function useCommentsErrorListener(callback) {
   const client = useClient();
   const savedCallback = useLatest(callback);
-  const { commentsErrorEventSource } = getExtrasForClient2(client);
+  const { commentsErrorEventSource } = getRoomExtrasForClient(client);
   React5.useEffect(() => {
     return commentsErrorEventSource.subscribe(savedCallback.current);
   }, [savedCallback, commentsErrorEventSource]);
@@ -2905,13 +2991,13 @@ function useCreateThread() {
         comments: [newComment],
         resolved: false
       };
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "create-thread",
         thread: newThread,
         roomId: room.id
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _25 => _25.map, 'call', _26 => _26((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _28 => _28.map, 'call', _29 => _29((attachment) => attachment.id)]);
       room.createThread({ threadId, commentId, body, metadata, attachmentIds }).then(
         (thread) => {
           store.createThread(optimisticUpdateId, thread);
@@ -2938,10 +3024,10 @@ function useDeleteThread() {
   const room = useRoom();
   return React5.useCallback(
     (threadId) => {
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const thread = store.getFullState().threadsById[threadId];
       const userId = getCurrentUserId(room);
-      if (_optionalChain([thread, 'optionalAccess', _27 => _27.comments, 'optionalAccess', _28 => _28[0], 'optionalAccess', _29 => _29.userId]) !== userId) {
+      if (_optionalChain([thread, 'optionalAccess', _30 => _30.comments, 'optionalAccess', _31 => _31[0], 'optionalAccess', _32 => _32.userId]) !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
       const optimisticUpdateId = store.addOptimisticUpdate({
@@ -2975,7 +3061,7 @@ function useEditThreadMetadata() {
       const threadId = options.threadId;
       const metadata = options.metadata;
       const updatedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "edit-thread-metadata",
         metadata,
@@ -3024,12 +3110,12 @@ function useCreateComment() {
         reactions: [],
         attachments: _nullishCoalesce(attachments, () => ( []))
       };
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "create-comment",
         comment
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _30 => _30.map, 'call', _31 => _31((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _33 => _33.map, 'call', _34 => _34((attachment) => attachment.id)]);
       room.createComment({ threadId, commentId, body, attachmentIds }).then(
         (newComment) => {
           store.createComment(newComment, optimisticUpdateId);
@@ -3056,7 +3142,7 @@ function useEditComment() {
   return React5.useCallback(
     ({ threadId, commentId, body, attachments }) => {
       const editedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const thread = store.getFullState().threadsById[threadId];
       if (thread === void 0) {
         _core.console.warn(
@@ -3082,7 +3168,7 @@ function useEditComment() {
           attachments: _nullishCoalesce(attachments, () => ( []))
         }
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _32 => _32.map, 'call', _33 => _33((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _35 => _35.map, 'call', _36 => _36((attachment) => attachment.id)]);
       room.editComment({ threadId, commentId, body, attachmentIds }).then(
         (editedComment) => {
           store.editComment(threadId, optimisticUpdateId, editedComment);
@@ -3108,7 +3194,7 @@ function useDeleteComment() {
   return React5.useCallback(
     ({ threadId, commentId }) => {
       const deletedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "delete-comment",
         threadId,
@@ -3146,7 +3232,7 @@ function useAddReaction() {
     ({ threadId, commentId, emoji }) => {
       const createdAt = /* @__PURE__ */ new Date();
       const userId = getCurrentUserId(room);
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "add-reaction",
         threadId,
@@ -3189,7 +3275,7 @@ function useRemoveReaction() {
     ({ threadId, commentId, emoji }) => {
       const userId = getCurrentUserId(room);
       const removedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "remove-reaction",
         threadId,
@@ -3229,9 +3315,9 @@ function useMarkThreadAsRead() {
   const room = useRoom();
   return React5.useCallback(
     (threadId) => {
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const inboxNotification = Object.values(
-        store.getFullState().inboxNotificationsById
+        store.getFullState().notificationsById
       ).find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
@@ -3271,7 +3357,7 @@ function useMarkThreadAsResolved() {
   return React5.useCallback(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "mark-thread-as-resolved",
         threadId,
@@ -3305,7 +3391,7 @@ function useMarkThreadAsUnresolved() {
   return React5.useCallback(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "mark-thread-as-unresolved",
         threadId,
@@ -3335,10 +3421,10 @@ function useMarkThreadAsUnresolved() {
 }
 function useThreadSubscription(threadId) {
   const client = useClient();
-  const { store } = getExtrasForClient2(client);
+  const { store } = getRoomExtrasForClient(client);
   const selector = React5.useCallback(
     (state) => {
-      const inboxNotification = state.inboxNotifications.find(
+      const inboxNotification = state.notifications.find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
       const thread = state.threadsById[threadId];
@@ -3365,13 +3451,13 @@ function useRoomNotificationSettings() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
   const client = useClient();
   const room = useRoom();
-  const { store } = getExtrasForClient2(client);
+  const { store } = getRoomExtrasForClient(client);
   const getter = React5.useCallback(
     () => store.getNotificationSettingsAsync(room.id),
     [store, room.id]
   );
   React5.useEffect(() => {
-    const { getInboxNotificationSettings } = getExtrasForClient2(client);
+    const { getInboxNotificationSettings } = getRoomExtrasForClient(client);
     void getInboxNotificationSettings(room);
   }, [client, room]);
   const settings = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
@@ -3379,7 +3465,7 @@ function useRoomNotificationSettings() {
     getter,
     getter,
     identity2,
-    _client.shallow
+    _client2.shallow
   );
   return React5.useMemo(() => {
     return [settings, updateRoomNotificationSettings];
@@ -3389,7 +3475,7 @@ function useRoomNotificationSettingsSuspense() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
   const client = useClient();
   const room = useRoom();
-  const { store } = getExtrasForClient2(client);
+  const { store } = getRoomExtrasForClient(client);
   const getter = React5.useCallback(
     () => store.getNotificationSettingsAsync(room.id),
     [store, room.id]
@@ -3399,10 +3485,10 @@ function useRoomNotificationSettingsSuspense() {
     getter,
     getter,
     identity2,
-    _client.shallow
+    _client2.shallow
   );
   if (settings.isLoading) {
-    const { getInboxNotificationSettings } = getExtrasForClient2(client);
+    const { getInboxNotificationSettings } = getRoomExtrasForClient(client);
     throw getInboxNotificationSettings(room);
   } else if (settings.error) {
     throw settings.error;
@@ -3443,7 +3529,7 @@ function useHistoryVersionData(versionId) {
 function useHistoryVersions() {
   const client = useClient();
   const room = useRoom();
-  const { store, getRoomVersions } = getExtrasForClient2(client);
+  const { store, getRoomVersions } = getRoomExtrasForClient(client);
   const getter = React5.useCallback(
     () => store.getVersionsAsync(room.id),
     [store, room.id]
@@ -3456,14 +3542,14 @@ function useHistoryVersions() {
     getter,
     getter,
     identity2,
-    _client.shallow
+    _client2.shallow
   );
   return state;
 }
 function useHistoryVersionsSuspense() {
   const client = useClient();
   const room = useRoom();
-  const { store } = getExtrasForClient2(client);
+  const { store } = getRoomExtrasForClient(client);
   const getter = React5.useCallback(
     () => store.getVersionsAsync(room.id),
     [store, room.id]
@@ -3473,10 +3559,10 @@ function useHistoryVersionsSuspense() {
     getter,
     getter,
     identity2,
-    _client.shallow
+    _client2.shallow
   );
   if (state.isLoading) {
-    const { getRoomVersions } = getExtrasForClient2(client);
+    const { getRoomVersions } = getRoomExtrasForClient(client);
     throw getRoomVersions(room);
   } else if (state.error) {
     throw state.error;
@@ -3488,7 +3574,7 @@ function useUpdateRoomNotificationSettings() {
   const room = useRoom();
   return React5.useCallback(
     (settings) => {
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "update-notification-settings",
         roomId: room.id,
@@ -3571,50 +3657,17 @@ function useStorageStatusSuspense(options) {
 function useThreadsSuspense(options = {
   query: { metadata: {} }
 }) {
-  const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
-  const queryKey = React5.useMemo(
-    () => generateQueryKey(room.id, options.query),
-    [room, options]
-  );
-  const { store, getThreadsAndInboxNotifications } = getExtrasForClient2(client);
-  const query = store.getFullState().queries2[queryKey];
-  if (query === void 0 || query.isLoading) {
-    throw getThreadsAndInboxNotifications(room, queryKey, options);
-  }
-  if (query.error) {
-    throw query.error;
-  }
-  const selector = React5.useCallback(
-    (state2) => {
-      return {
-        threads: selectThreads(state2, {
-          roomId: room.id,
-          query: options.query,
-          orderBy: "age"
-        }),
-        isLoading: false
-      };
-    },
-    [room, queryKey]
-    // eslint-disable-line react-hooks/exhaustive-deps
-  );
-  React5.useEffect(() => {
-    const { incrementQuerySubscribers } = getExtrasForClient2(client);
-    return incrementQuerySubscribers(queryKey);
-  }, [client, queryKey]);
-  const state = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribeThreads,
-    store.getFullState,
-    store.getFullState,
-    selector
-  );
-  useScrollToCommentOnLoadEffect(scrollOnLoad, state);
-  return state;
+  const { store } = getRoomExtrasForClient(client);
+  use(store.waitUntilRoomThreadsLoaded(room.id, options.query));
+  const result = useThreads(options);
+  _core.assert.call(void 0, !result.error, "Did not expect error");
+  _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
+  return result;
 }
 function selectorFor_useAttachmentUrl(state) {
-  if (state === void 0 || _optionalChain([state, 'optionalAccess', _34 => _34.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _37 => _37.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -3641,7 +3694,7 @@ function useAttachmentUrl(attachmentId) {
     getAttachmentUrlState,
     getAttachmentUrlState,
     selectorFor_useAttachmentUrl,
-    _client.shallow
+    _client2.shallow
   );
 }
 function useAttachmentUrlSuspense(attachmentId) {
@@ -3675,9 +3728,6 @@ function useAttachmentUrlSuspense(attachmentId) {
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
 }
-function generateQueryKey(roomId, options) {
-  return `${roomId}-${_core.stringify.call(void 0, _nullishCoalesce(options, () => ( {})))}`;
-}
 var _RoomProvider = RoomProvider;
 var _useBroadcastEvent = useBroadcastEvent;
 var _useOthersListener = useOthersListener;
@@ -3799,5 +3849,5 @@ var _useUpdateMyPresence = useUpdateMyPresence;
 
 
 
-exports.PKG_NAME = PKG_NAME; exports.PKG_VERSION = PKG_VERSION; exports.PKG_FORMAT = PKG_FORMAT; exports.ClientSideSuspense = ClientSideSuspense; exports.RoomContext = RoomContext; exports.ClientContext = ClientContext; exports.selectThreads = selectThreads; exports.getUmbrellaStoreForClient = getUmbrellaStoreForClient; exports.useClient = useClient; exports.LiveblocksProvider = LiveblocksProvider; exports.createLiveblocksContext = createLiveblocksContext; exports.useInboxNotifications = useInboxNotifications; exports.useInboxNotificationsSuspense = useInboxNotificationsSuspense; exports.useMarkAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead; exports.useMarkInboxNotificationAsRead = useMarkInboxNotificationAsRead; exports.useDeleteAllInboxNotifications = useDeleteAllInboxNotifications; exports.useDeleteInboxNotification = useDeleteInboxNotification; exports.useUnreadInboxNotificationsCount = useUnreadInboxNotificationsCount; exports.useUnreadInboxNotificationsCountSuspense = useUnreadInboxNotificationsCountSuspense; exports.useRoomInfo = useRoomInfo; exports.useRoomInfoSuspense = useRoomInfoSuspense; exports._useInboxNotificationThread = _useInboxNotificationThread; exports._useUser = _useUser; exports._useUserSuspense = _useUserSuspense; exports._useUserThreads_experimental = _useUserThreads_experimental; exports._useUserThreadsSuspense_experimental = _useUserThreadsSuspense_experimental; exports.CreateThreadError = CreateThreadError; exports.useStatus = useStatus; exports.useStorageStatus = useStorageStatus; exports.useBatch = useBatch; exports.useLostConnectionListener = useLostConnectionListener; exports.useErrorListener = useErrorListener; exports.useHistory = useHistory; exports.useUndo = useUndo; exports.useRedo = useRedo; exports.useCanUndo = useCanUndo; exports.useCanRedo = useCanRedo; exports.useOthersConnectionIds = useOthersConnectionIds; exports.useCommentsErrorListener = useCommentsErrorListener; exports.useCreateComment = useCreateComment; exports.useEditComment = useEditComment; exports.useDeleteComment = useDeleteComment; exports.useRemoveReaction = useRemoveReaction; exports.useMarkThreadAsRead = useMarkThreadAsRead; exports.useMarkThreadAsResolved = useMarkThreadAsResolved; exports.useMarkThreadAsUnresolved = useMarkThreadAsUnresolved; exports.useThreadSubscription = useThreadSubscription; exports.useRoomNotificationSettings = useRoomNotificationSettings; exports.useHistoryVersionData = useHistoryVersionData; exports.useUpdateRoomNotificationSettings = useUpdateRoomNotificationSettings; exports.useOthersConnectionIdsSuspense = useOthersConnectionIdsSuspense; exports.useStorageStatusSuspense = useStorageStatusSuspense; exports.useAttachmentUrl = useAttachmentUrl; exports.useAttachmentUrlSuspense = useAttachmentUrlSuspense; exports.createRoomContext = createRoomContext; exports._RoomProvider = _RoomProvider; exports._useBroadcastEvent = _useBroadcastEvent; exports._useOthersListener = _useOthersListener; exports._useRoom = _useRoom; exports._useIsInsideRoom = _useIsInsideRoom; exports._useAddReaction = _useAddReaction; exports._useMutation = _useMutation; exports._useCreateThread = _useCreateThread; exports._useDeleteThread = _useDeleteThread; exports._useEditThreadMetadata = _useEditThreadMetadata; exports._useEventListener = _useEventListener; exports._useMyPresence = _useMyPresence; exports._useOthersMapped = _useOthersMapped; exports._useOthersMappedSuspense = _useOthersMappedSuspense; exports._useThreads = _useThreads; exports._useThreadsSuspense = _useThreadsSuspense; exports._useHistoryVersions = _useHistoryVersions; exports._useHistoryVersionsSuspense = _useHistoryVersionsSuspense; exports._useOther = _useOther; exports._useOthers = _useOthers; exports._useOtherSuspense = _useOtherSuspense; exports._useOthersSuspense = _useOthersSuspense; exports._useStorage = _useStorage; exports._useStorageSuspense = _useStorageSuspense; exports._useSelf = _useSelf; exports._useSelfSuspense = _useSelfSuspense; exports._useStorageRoot = _useStorageRoot; exports._useUpdateMyPresence = _useUpdateMyPresence;
-//# sourceMappingURL=chunk-HPI4YG7I.js.map
+exports.PKG_NAME = PKG_NAME; exports.PKG_VERSION = PKG_VERSION; exports.PKG_FORMAT = PKG_FORMAT; exports.ClientSideSuspense = ClientSideSuspense; exports.RoomContext = RoomContext; exports.selectThreads = selectThreads; exports.ClientContext = ClientContext; exports.getUmbrellaStoreForClient = getUmbrellaStoreForClient; exports.useClient = useClient; exports.LiveblocksProvider = LiveblocksProvider; exports.createLiveblocksContext = createLiveblocksContext; exports.useInboxNotifications = useInboxNotifications; exports.useInboxNotificationsSuspense = useInboxNotificationsSuspense; exports.useMarkAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead; exports.useMarkInboxNotificationAsRead = useMarkInboxNotificationAsRead; exports.useDeleteAllInboxNotifications = useDeleteAllInboxNotifications; exports.useDeleteInboxNotification = useDeleteInboxNotification; exports.useUnreadInboxNotificationsCount = useUnreadInboxNotificationsCount; exports.useUnreadInboxNotificationsCountSuspense = useUnreadInboxNotificationsCountSuspense; exports.useRoomInfo = useRoomInfo; exports.useRoomInfoSuspense = useRoomInfoSuspense; exports._useInboxNotificationThread = _useInboxNotificationThread; exports._useUser = _useUser; exports._useUserSuspense = _useUserSuspense; exports._useUserThreads_experimental = _useUserThreads_experimental; exports._useUserThreadsSuspense_experimental = _useUserThreadsSuspense_experimental; exports.CreateThreadError = CreateThreadError; exports.useStatus = useStatus; exports.useStorageStatus = useStorageStatus; exports.useBatch = useBatch; exports.useLostConnectionListener = useLostConnectionListener; exports.useErrorListener = useErrorListener; exports.useHistory = useHistory; exports.useUndo = useUndo; exports.useRedo = useRedo; exports.useCanUndo = useCanUndo; exports.useCanRedo = useCanRedo; exports.useOthersConnectionIds = useOthersConnectionIds; exports.useCommentsErrorListener = useCommentsErrorListener; exports.useCreateComment = useCreateComment; exports.useEditComment = useEditComment; exports.useDeleteComment = useDeleteComment; exports.useRemoveReaction = useRemoveReaction; exports.useMarkThreadAsRead = useMarkThreadAsRead; exports.useMarkThreadAsResolved = useMarkThreadAsResolved; exports.useMarkThreadAsUnresolved = useMarkThreadAsUnresolved; exports.useThreadSubscription = useThreadSubscription; exports.useRoomNotificationSettings = useRoomNotificationSettings; exports.useHistoryVersionData = useHistoryVersionData; exports.useUpdateRoomNotificationSettings = useUpdateRoomNotificationSettings; exports.useOthersConnectionIdsSuspense = useOthersConnectionIdsSuspense; exports.useStorageStatusSuspense = useStorageStatusSuspense; exports.useAttachmentUrl = useAttachmentUrl; exports.useAttachmentUrlSuspense = useAttachmentUrlSuspense; exports.createRoomContext = createRoomContext; exports._RoomProvider = _RoomProvider; exports._useBroadcastEvent = _useBroadcastEvent; exports._useOthersListener = _useOthersListener; exports._useRoom = _useRoom; exports._useIsInsideRoom = _useIsInsideRoom; exports._useAddReaction = _useAddReaction; exports._useMutation = _useMutation; exports._useCreateThread = _useCreateThread; exports._useDeleteThread = _useDeleteThread; exports._useEditThreadMetadata = _useEditThreadMetadata; exports._useEventListener = _useEventListener; exports._useMyPresence = _useMyPresence; exports._useOthersMapped = _useOthersMapped; exports._useOthersMappedSuspense = _useOthersMappedSuspense; exports._useThreads = _useThreads; exports._useThreadsSuspense = _useThreadsSuspense; exports._useHistoryVersions = _useHistoryVersions; exports._useHistoryVersionsSuspense = _useHistoryVersionsSuspense; exports._useOther = _useOther; exports._useOthers = _useOthers; exports._useOtherSuspense = _useOtherSuspense; exports._useOthersSuspense = _useOthersSuspense; exports._useStorage = _useStorage; exports._useStorageSuspense = _useStorageSuspense; exports._useSelf = _useSelf; exports._useSelfSuspense = _useSelfSuspense; exports._useStorageRoot = _useStorageRoot; exports._useUpdateMyPresence = _useUpdateMyPresence;
+//# sourceMappingURL=chunk-7P6EIISH.js.map