@liveblocks/react 2.8.3-tiptap1 → 2.8.3-tiptap2

package/dist/{chunk-464Q66DF.mjs → chunk-BNSPCUSO.mjs}

@@ -1,6 +1,6 @@
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "2.8.3-tiptap1";
+var PKG_VERSION = "2.8.3-tiptap2";
 var PKG_FORMAT = "esm";
 
 // src/ClientSideSuspense.tsx
@@ -24,27 +24,37 @@ function useIsInsideRoom() {
   return room !== null;
 }
 
-// src/liveblocks.tsx
+// src/umbrella-store.ts
 import {
-  assert,
   autoRetry,
-  createClient,
+  compactObject,
+  console as console2,
+  createStore,
   kInternal,
-  makePoller,
-  memoizeOnSuccess,
-  raise,
-  shallow as shallow3,
+  makeEventSource,
+  mapValues,
+  nanoid,
+  nn,
+  StopRetrying,
   stringify
 } from "@liveblocks/core";
-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/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 descriptor?.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) {
@@ -54,7 +64,7 @@ function isMoreRecentlyUpdated(a, b) {
   return byMostRecentlyUpdated(a, b) < 0;
 }
 function byMostRecentlyUpdated(a, b) {
-  return (b.updatedAt ?? b.createdAt).getTime() - (a.updatedAt ?? a.createdAt).getTime();
+  return b.updatedAt.getTime() - a.updatedAt.getTime();
 }
 
 // src/lib/guards.ts
@@ -77,8 +87,11 @@ function matchesMetadata(thread, q) {
   const metadata = thread.metadata;
   return q.metadata === void 0 || Object.entries(q.metadata).every(
     ([key, op]) => (
-      // Boolean logic: op? => value matches the operator
-      op === void 0 || matchesOperator(metadata[key], op)
+      // NOTE: `op` can be explicitly-`undefined` here, which ideally would not
+      // mean "filter for absence" like it does now, as this does not match the
+      // backend behavior at the moment. For an in-depth discussion, see
+      // https://liveblocks.slack.com/archives/C02PZL7QAAW/p1728546988505989
+      matchesOperator(metadata[key], op)
     )
   );
 }
@@ -90,131 +103,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}-${stringify(query ?? {})}`;
 }
-
-// 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);
+function makeUserThreadsQueryKey(query) {
+  return `USER_THREADS:${stringify(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) && shallow(a[key], b[key])
+  return threads.sort(
+    options.orderBy === "last-update" ? byMostRecentlyUpdated : byFirstCreated
   );
 }
-
-// src/lib/use-initial.ts
-import { useCallback, useReducer } from "react";
-
-// src/lib/use-latest.ts
-import { useEffect as useEffect2, useRef } from "react";
-function useLatest(value) {
-  const ref = useRef(value);
-  useEffect2(() => {
-    ref.current = value;
-  }, [value]);
-  return ref;
-}
-
-// src/lib/use-initial.ts
-var noop = (state) => state;
-function useInitial(value) {
-  return useReducer(noop, value)[0];
-}
-function useInitialUnlessFunction(latestValue) {
-  const frozenValue = useInitial(latestValue);
-  if (typeof frozenValue === "function") {
-    const ref = useLatest(latestValue);
-    return useCallback((...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 = makeEventSource();
+    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 (!state?.cursor) {
+      return;
+    }
+    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
-import {
-  compactObject,
-  console as console2,
-  createStore,
-  mapValues,
-  nanoid,
-  nn
-} from "@liveblocks/core";
-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 (state?.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 = autoRetry(
+      () => 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 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 = createStore({
       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 +317,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 +403,7 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      settings: nn(state.notificationSettingsByRoomId[roomId])
+      settings: nn(state.settingsByRoomId[roomId])
     };
   }
   getVersionsAsync(roomId) {
@@ -339,15 +459,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 +481,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,
@@ -493,7 +598,7 @@ var UmbrellaStore = class {
         if (existing.deletedAt !== void 0) {
           return cache;
         }
-        if (!!updatedAt && !!existing.updatedAt && existing.updatedAt > updatedAt) {
+        if (!!updatedAt && existing.updatedAt > updatedAt) {
           return cache;
         }
         return { ...cache, [threadId]: callback(existing) };
@@ -602,7 +707,7 @@ var UmbrellaStore = class {
       }
     });
   }
-  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads, deletedInboxNotifications) {
+  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
     this._store.batch(() => {
       this.updateThreadsCache(
         (cache) => applyThreadUpdates(cache, {
@@ -622,12 +727,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 +760,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 +780,159 @@ var UmbrellaStore = class {
   setQuery4Error(queryKey, error) {
     this.setQuery4State(queryKey, { isLoading: false, error });
   }
+  async fetchNotificationsDeltaUpdate() {
+    const lastRequestedAt = this._notificationsLastRequestedAt;
+    if (lastRequestedAt === null) {
+      return;
+    }
+    const client = nn(
+      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 StopRetrying(
+          "Client is required in order to load threads for the room"
+        );
+      }
+      const room = this._client.getRoom(roomId);
+      if (room === null) {
+        throw new 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) {
+      return;
+    }
+    const client = nn(
+      this._client,
+      "Client is required in order to load notifications for the room"
+    );
+    const room = nn(
+      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 StopRetrying(
+          "Client is required in order to load threads for the room"
+        );
+      }
+      const result = await this._client[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) {
+      return;
+    }
+    const client = nn(
+      this._client,
+      "Client is required in order to load threads for the user"
+    );
+    const result = await client[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) {
@@ -717,7 +948,7 @@ function internalToExternalState(state) {
         if (thread.deletedAt !== void 0) {
           break;
         }
-        if (thread.updatedAt !== void 0 && thread.updatedAt > optimisticUpdate.updatedAt) {
+        if (thread.updatedAt > optimisticUpdate.updatedAt) {
           break;
         }
         computed.threadsById[thread.id] = {
@@ -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(
+    Object.values(computed.notificationsById).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,
-    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(thread.updatedAt?.getTime() || 0, comment.createdAt.getTime())
+      Math.max(thread.updatedAt.getTime(), comment.createdAt.getTime())
     );
     const updatedThread = {
       ...thread,
@@ -998,7 +1231,7 @@ function applyUpsertComment(thread, comment) {
       ...thread,
       updatedAt: new Date(
         Math.max(
-          thread.updatedAt?.getTime() || 0,
+          thread.updatedAt.getTime(),
           comment.editedAt?.getTime() || comment.createdAt.getTime()
         )
       ),
@@ -1065,7 +1298,7 @@ function applyAddReaction(thread, commentId, reaction) {
   return {
     ...thread,
     updatedAt: new Date(
-      Math.max(reaction.createdAt.getTime(), thread.updatedAt?.getTime() || 0)
+      Math.max(reaction.createdAt.getTime(), thread.updatedAt.getTime())
     ),
     comments: updatedComments
   };
@@ -1098,7 +1331,7 @@ function applyRemoveReaction(thread, commentId, emoji, userId, removedAt) {
   return {
     ...thread,
     updatedAt: new Date(
-      Math.max(removedAt.getTime(), thread.updatedAt?.getTime() || 0)
+      Math.max(removedAt.getTime(), thread.updatedAt.getTime())
     ),
     comments: updatedComments
   };
@@ -1125,9 +1358,100 @@ function upsertReaction(reactions, reaction) {
       } : existingReaction2
     );
   }
-  return reactions;
+  return reactions;
+}
+
+// src/liveblocks.tsx
+import {
+  assert,
+  createClient,
+  kInternal as kInternal2,
+  makePoller,
+  raise,
+  shallow as shallow3
+} from "@liveblocks/core";
+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/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";
+
+// src/lib/use-latest.ts
+import { useEffect as useEffect2, useRef } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  useEffect2(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// src/lib/use-initial.ts
+var noop2 = (state) => state;
+function useInitial(value) {
+  return useReducer(noop2, value)[0];
+}
+function useInitialUnlessFunction(latestValue) {
+  const frozenValue = useInitial(latestValue);
+  if (typeof frozenValue === "function") {
+    const ref = useLatest(latestValue);
+    return useCallback((...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 = createContext2(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) {
@@ -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 = makePoller(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 = memoizeOnSuccess(async () => {
-    store.setQuery1Loading();
-    try {
-      await autoRetry(
-        () => 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 = makePoller(refreshUserThreads);
-  let isFetchingUserThreadsUpdates = false;
-  async function refreshUserThreads() {
-    const since = userThreadslastRequestedAt;
-    if (since === void 0 || isFetchingUserThreadsUpdates) {
-      return;
-    }
+  };
+}
+function makeDeltaPoller_UserThreads(store) {
+  const poller = makePoller(async () => {
     try {
-      isFetchingUserThreadsUpdates = true;
-      const updates = await client[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 = 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[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, shallow3),
     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);
-  useEffect3(loadInboxNotifications, [loadInboxNotifications]);
-  useEffect3(startPolling, [startPolling]);
+function useInboxNotifications_withClient(client, selector, isEqual) {
+  const {
+    store,
+    subscribeToNotificationsDeltaUpdates: subscribeToDeltaUpdates
+  } = getLiveblocksExtrasForClient(client);
+  useEffect3(() => {
+    void store.waitUntilNotificationsLoaded().catch(() => {
+    });
+  });
+  useEffect3(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
   return useSyncExternalStoreWithSelector(
     store.subscribeThreadsOrInboxNotifications,
     store.getInboxNotificationsAsync,
     store.getInboxNotificationsAsync,
-    identity,
-    shallow3
+    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, shallow3);
   assert(!result.error, "Did not expect error");
   assert(!result.isLoading, "Did not expect loading");
   return result;
 }
 function useUnreadInboxNotificationsCount_withClient(client) {
-  const { store, loadInboxNotifications, startPolling } = getExtrasForClient(client);
-  useEffect3(loadInboxNotifications, [loadInboxNotifications]);
-  useEffect3(startPolling, [startPolling]);
-  return useSyncExternalStoreWithSelector(
-    store.subscribeThreadsOrInboxNotifications,
-    store.getInboxNotificationsAsync,
-    store.getInboxNotificationsAsync,
+  return useInboxNotifications_withClient(
+    client,
     selectorFor_useUnreadInboxNotificationsCount,
     shallow3
   );
 }
 function useUnreadInboxNotificationsCountSuspense_withClient(client) {
-  const { waitUntilInboxNotificationsLoaded } = getExtrasForClient(client);
-  use(waitUntilInboxNotificationsLoaded());
+  const store = getLiveblocksExtrasForClient(client).store;
+  use(store.waitUntilNotificationsLoaded());
   const result = useUnreadInboxNotificationsCount_withClient(client);
   assert(!result.isLoading, "Did not expect loading");
   assert(!result.error, "Did not expect error");
@@ -1487,7 +1685,7 @@ function useUnreadInboxNotificationsCountSuspense_withClient(client) {
 function useMarkInboxNotificationAsRead_withClient(client) {
   return useCallback2(
     (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 useCallback2(() => {
-    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 useCallback2(
     (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 useCallback2(() => {
-    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 = useCallback2(
     (state) => {
-      const inboxNotification = state.inboxNotificationsById[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
+      const inboxNotification = state.notificationsById[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
       if (inboxNotification.kind !== "thread") {
         raise(
           `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
@@ -1601,7 +1799,7 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
   );
 }
 function useUser_withClient(client, userId) {
-  const usersStore = client[kInternal].usersStore;
+  const usersStore = client[kInternal2].usersStore;
   const getUserState = useCallback2(
     () => usersStore.getState(userId),
     [usersStore, userId]
@@ -1622,7 +1820,7 @@ function useUser_withClient(client, userId) {
   );
 }
 function useUserSuspense_withClient(client, userId) {
-  const usersStore = client[kInternal].usersStore;
+  const usersStore = client[kInternal2].usersStore;
   const getUserState = useCallback2(
     () => usersStore.getState(userId),
     [usersStore, userId]
@@ -1652,7 +1850,7 @@ function useUserSuspense_withClient(client, userId) {
   };
 }
 function useRoomInfo_withClient(client, roomId) {
-  const roomsInfoStore = client[kInternal].roomsInfoStore;
+  const roomsInfoStore = client[kInternal2].roomsInfoStore;
   const getRoomInfoState = useCallback2(
     () => roomsInfoStore.getState(roomId),
     [roomsInfoStore, roomId]
@@ -1673,7 +1871,7 @@ function useRoomInfo_withClient(client, roomId) {
   );
 }
 function useRoomInfoSuspense_withClient(client, roomId) {
-  const roomsInfoStore = client[kInternal].roomsInfoStore;
+  const roomsInfoStore = client[kInternal2].roomsInfoStore;
   const getRoomInfoState = useCallback2(
     () => roomsInfoStore.getState(roomId),
     [roomsInfoStore, roomId]
@@ -1774,40 +1972,32 @@ function useUserThreads_experimental(options = {
     metadata: {}
   }
 }) {
-  const queryKey = React3.useMemo(
-    () => makeUserThreadsQueryKey(options.query),
-    [options]
-  );
   const client = useClient();
-  const { store, incrementUserThreadsQuerySubscribers, getUserThreads } = getExtrasForClient(client);
-  useEffect3(() => {
-    void getUserThreads(queryKey, options);
-    return incrementUserThreadsQuerySubscribers(queryKey);
-  }, [queryKey, incrementUserThreadsQuerySubscribers, getUserThreads, options]);
-  const getter = useCallback2(
-    () => store.getUserThreadsAsync(queryKey),
-    [store, queryKey]
-  );
-  const selector = useCallback2(
-    (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);
+  useEffect3(
+    () => {
+      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.
+  );
+  useEffect3(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  const getter = useCallback2(
+    () => store.getUserThreadsAsync(options.query),
+    [store, options.query]
   );
   return useSyncExternalStoreWithSelector(
     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 = React3.useMemo(
-    () => makeUserThreadsQueryKey(options.query),
-    [options]
-  );
   const client = useClient();
-  const { store, getUserThreads } = getExtrasForClient(client);
-  React3.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 = 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.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);
+  assert(!result.error, "Did not expect error");
+  assert(!result.isLoading, "Did not expect loading");
+  return result;
 }
 function useInboxNotifications() {
-  return useInboxNotifications_withClient(useClient());
+  return useInboxNotifications_withClient(useClient(), identity, shallow3);
 }
 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}:${stringify(options)}`;
 
 // src/types/errors.ts
 var CreateThreadError = class extends Error {
@@ -2017,16 +2173,26 @@ import {
   createThreadId,
   deprecateIf,
   errorIf,
-  kInternal as kInternal2,
-  makeEventSource,
+  kInternal as kInternal3,
+  makeEventSource as makeEventSource2,
   makePoller as makePoller2,
   NotificationsApiError,
-  ServerMsgCode,
-  stringify as stringify2
+  ServerMsgCode
 } from "@liveblocks/core";
 import * as React5 from "react";
 import { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from "use-sync-external-store/shim/with-selector.js";
 
+// 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
 import * as React4 from "react";
 function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
@@ -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:
@@ -2132,6 +2298,28 @@ function handleApiError(err) {
   }
   return new Error(message);
 }
+function makeDeltaPoller_RoomThreads(client) {
+  const store = getUmbrellaStoreForClient(client);
+  const poller = makePoller2(async () => {
+    const roomIds = client[kInternal3].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,83 +2330,22 @@ 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 = makePoller2(refreshThreadsAndNotifications);
-  async function refreshThreadsAndNotifications() {
-    const requests = [];
-    client[kInternal2].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 = 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) {
-        console3.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 = 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);
     if (existingRequest !== void 0) return existingRequest;
-    const request = room[kInternal2].listTextVersions();
+    const request = room[kInternal3].listTextVersions();
     requestsByQuery.set(queryKey, request);
     store.setQuery4Loading(queryKey);
     try {
@@ -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);
@@ -2298,7 +2391,7 @@ function makeExtrasForClient2(client) {
     }
     return;
   }
-  const commentsErrorEventSource = makeEventSource();
+  const commentsErrorEventSource = makeEventSource2();
   function onMutationFailure(innerError, optimisticUpdateId, createPublicError) {
     store.removeOptimisticUpdate(optimisticUpdateId);
     if (innerError instanceof CommentsApiError) {
@@ -2314,10 +2407,8 @@ function makeExtrasForClient2(client) {
   }
   return {
     store,
-    incrementQuerySubscribers,
+    subscribeToRoomThreadsDeltaUpdates: makeDeltaPoller_RoomThreads(client),
     commentsErrorEventSource,
-    getThreadsUpdates,
-    getThreadsAndInboxNotifications,
     getInboxNotificationSettings,
     getRoomVersions,
     onMutationFailure
@@ -2423,7 +2514,7 @@ function makeRoomContextBundle(client) {
     },
     useCommentsErrorListener
   };
-  return Object.defineProperty(bundle, kInternal2, {
+  return Object.defineProperty(bundle, kInternal3, {
     enumerable: false
   });
 }
@@ -2492,7 +2583,7 @@ function RoomProviderInner(props) {
     })
   );
   React5.useEffect(() => {
-    const { store } = getExtrasForClient2(client);
+    const { store } = getRoomExtrasForClient(client);
     async function handleCommentEvent(message) {
       if (message.type === 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 () => {
@@ -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 = useSyncExternalStoreWithSelector2(
     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,7 +2991,7 @@ 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,
@@ -2938,7 +3024,7 @@ 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 (thread?.comments?.[0]?.userId !== userId) {
@@ -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,7 +3110,7 @@ function useCreateComment() {
         reactions: [],
         attachments: attachments ?? []
       };
-      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
         type: "create-comment",
         comment
@@ -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) {
         console3.warn(
@@ -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 = useSyncExternalStoreWithSelector2(
@@ -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]
@@ -3402,7 +3488,7 @@ function useRoomNotificationSettingsSuspense() {
     shallow4
   );
   if (settings.isLoading) {
-    const { getInboxNotificationSettings } = getExtrasForClient2(client);
+    const { getInboxNotificationSettings } = getRoomExtrasForClient(client);
     throw getInboxNotificationSettings(room);
   } else if (settings.error) {
     throw settings.error;
@@ -3420,7 +3506,7 @@ function useHistoryVersionData(versionId) {
     setState({ isLoading: true });
     const load = async () => {
       try {
-        const response = await room[kInternal2].getTextVersion(versionId);
+        const response = await room[kInternal3].getTextVersion(versionId);
         const buffer = await response.arrayBuffer();
         const data = new Uint8Array(buffer);
         setState({
@@ -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]
@@ -3463,7 +3549,7 @@ function useHistoryVersions() {
 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]
@@ -3476,7 +3562,7 @@ function useHistoryVersionsSuspense() {
     shallow4
   );
   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,47 +3657,14 @@ 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 = useSyncExternalStoreWithSelector2(
-    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);
+  assert2(!result.error, "Did not expect error");
+  assert2(!result.isLoading, "Did not expect loading");
+  return result;
 }
 function selectorFor_useAttachmentUrl(state) {
   if (state === void 0 || state?.isLoading) {
@@ -3628,7 +3681,7 @@ function selectorFor_useAttachmentUrl(state) {
 }
 function useAttachmentUrl(attachmentId) {
   const room = useRoom();
-  const { attachmentUrlsStore } = room[kInternal2];
+  const { attachmentUrlsStore } = room[kInternal3];
   const getAttachmentUrlState = React5.useCallback(
     () => attachmentUrlsStore.getState(attachmentId),
     [attachmentUrlsStore, attachmentId]
@@ -3646,7 +3699,7 @@ function useAttachmentUrl(attachmentId) {
 }
 function useAttachmentUrlSuspense(attachmentId) {
   const room = useRoom();
-  const { attachmentUrlsStore } = room[kInternal2];
+  const { attachmentUrlsStore } = room[kInternal3];
   const getAttachmentUrlState = React5.useCallback(
     () => attachmentUrlsStore.getState(attachmentId),
     [attachmentUrlsStore, attachmentId]
@@ -3675,9 +3728,6 @@ function useAttachmentUrlSuspense(attachmentId) {
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
 }
-function generateQueryKey(roomId, options) {
-  return `${roomId}-${stringify2(options ?? {})}`;
-}
 var _RoomProvider = RoomProvider;
 var _useBroadcastEvent = useBroadcastEvent;
 var _useOthersListener = useOthersListener;
@@ -3721,8 +3771,8 @@ export {
   PKG_FORMAT,
   ClientSideSuspense,
   RoomContext,
-  ClientContext,
   selectThreads,
+  ClientContext,
   getUmbrellaStoreForClient,
   useClient,
   LiveblocksProvider,
@@ -3800,4 +3850,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-464Q66DF.mjs.map
+//# sourceMappingURL=chunk-BNSPCUSO.mjs.map