@liveblocks/react 2.10.0 → 2.10.1-react19rc

package/dist/{chunk-LMENFXCS.mjs → chunk-A7GJNN4L.mjs}

@@ -9,18 +9,125 @@ function useIsInsideRoom() {
   return room !== null;
 }
 
+// src/liveblocks.tsx
+import {
+  assert,
+  createClient,
+  kInternal as kInternal2,
+  makePoller,
+  raise,
+  shallow as shallow3
+} from "@liveblocks/core";
+import React2, {
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  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/config.ts
+var SECONDS = 1e3;
+var MINUTES = 60 * SECONDS;
+var config = {
+  NOTIFICATIONS_POLL_INTERVAL: 1 * MINUTES,
+  NOTIFICATIONS_MAX_STALE_TIME: 5 * SECONDS,
+  ROOM_THREADS_POLL_INTERVAL: 5 * MINUTES,
+  ROOM_THREADS_MAX_STALE_TIME: 5 * SECONDS,
+  USER_THREADS_POLL_INTERVAL: 1 * MINUTES,
+  USER_THREADS_MAX_STALE_TIME: 5 * SECONDS,
+  HISTORY_VERSIONS_POLL_INTERVAL: 1 * MINUTES,
+  HISTORY_VERSIONS_MAX_STALE_TIME: 5 * SECONDS,
+  NOTIFICATION_SETTINGS_POLL_INTERVAL: 1 * MINUTES,
+  NOTIFICATION_SETTINGS_MAX_STALE_TIME: 5 * SECONDS
+};
+
+// src/lib/shallow2.ts
+import { isPlainObject, shallow } from "@liveblocks/core";
+function shallow2(a, b) {
+  if (!isPlainObject(a) || !isPlainObject(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, useRef } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  useEffect(() => {
+    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;
+  }
+}
+
+// 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/umbrella-store.ts
 import {
   autoRetry,
   compactObject,
   console as console2,
   createStore,
+  HttpError,
   kInternal,
   makeEventSource,
   mapValues,
   nanoid,
   nn,
-  StopRetrying,
   stringify
 } from "@liveblocks/core";
 
@@ -41,21 +148,13 @@ function autobind(self) {
   } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
 }
 
-// src/lib/compare.ts
-function byFirstCreated(a, b) {
-  return a.createdAt.getTime() - b.createdAt.getTime();
-}
-function isMoreRecentlyUpdated(a, b) {
-  return byMostRecentlyUpdated(a, b) < 0;
-}
-function byMostRecentlyUpdated(a, b) {
-  return b.updatedAt.getTime() - a.updatedAt.getTime();
-}
+// src/ThreadDB.ts
+import { SortedList } from "@liveblocks/core";
 
 // src/lib/guards.ts
-import { isPlainObject } from "@liveblocks/core";
+import { isPlainObject as isPlainObject2 } from "@liveblocks/core";
 function isStartsWith(blob) {
-  return isPlainObject(blob) && isString(blob.startsWith);
+  return isPlainObject2(blob) && isString(blob.startsWith);
 }
 function isString(value) {
   return typeof value === "string";
@@ -88,8 +187,124 @@ function matchesOperator(value, op) {
   }
 }
 
+// src/ThreadDB.ts
+function sanitizeThread(thread) {
+  if (thread.deletedAt) {
+    if (thread.comments.length > 0) {
+      return { ...thread, comments: [] };
+    }
+  }
+  const hasComment = thread.comments.some((c) => !c.deletedAt);
+  if (!hasComment) {
+    return { ...thread, deletedAt: /* @__PURE__ */ new Date(), comments: [] };
+  }
+  return thread;
+}
+var ThreadDB = class _ThreadDB {
+  // The version is auto-incremented on every mutation and can be used as a reliable indicator to tell if the contents of the thread pool has changed
+  constructor() {
+    this._asc = SortedList.from([], (t1, t2) => {
+      const d1 = t1.createdAt;
+      const d2 = t2.createdAt;
+      return d1 < d2 ? true : d1 === d2 ? t1.id < t2.id : false;
+    });
+    this._desc = SortedList.from([], (t1, t2) => {
+      const d2 = t2.updatedAt;
+      const d1 = t1.updatedAt;
+      return d2 < d1 ? true : d2 === d1 ? t2.id < t1.id : false;
+    });
+    this._byId = /* @__PURE__ */ new Map();
+    this._version = 0;
+  }
+  //
+  // Public APIs
+  //
+  clone() {
+    const newPool = new _ThreadDB();
+    newPool._byId = new Map(this._byId);
+    newPool._asc = this._asc.clone();
+    newPool._desc = this._desc.clone();
+    newPool._version = this._version;
+    return newPool;
+  }
+  /** Gets the transaction count for this DB. Increments any time the DB is modified. */
+  get version() {
+    return this._version;
+  }
+  /** Returns an existing thread by ID. Will never return a deleted thread. */
+  get(threadId) {
+    const thread = this.getEvenIfDeleted(threadId);
+    return thread?.deletedAt ? void 0 : thread;
+  }
+  /** Returns the (possibly deleted) thread by ID. */
+  getEvenIfDeleted(threadId) {
+    return this._byId.get(threadId);
+  }
+  /** Adds or updates a thread in the DB. If the newly given thread is a deleted one, it will get deleted. */
+  upsert(thread) {
+    thread = sanitizeThread(thread);
+    const id = thread.id;
+    const toRemove = this._byId.get(id);
+    if (toRemove) {
+      if (toRemove.deletedAt) return;
+      this._asc.remove(toRemove);
+      this._desc.remove(toRemove);
+    }
+    if (!thread.deletedAt) {
+      this._asc.add(thread);
+      this._desc.add(thread);
+    }
+    this._byId.set(id, thread);
+    this.touch();
+  }
+  /** Like .upsert(), except it won't update if a thread by this ID already exists. */
+  // TODO Consider renaming this to just .upsert(). I'm not sure if we really
+  // TODO need the raw .upsert(). Would be nice if this behavior was the default.
+  upsertIfNewer(thread) {
+    const existing = this.get(thread.id);
+    if (!existing || thread.updatedAt >= existing.updatedAt) {
+      this.upsert(thread);
+    }
+  }
+  /**
+   * Marks a thread as deleted. It will no longer pop up in .findMany()
+   * queries, but it can still be accessed via `.getEvenIfDeleted()`.
+   */
+  delete(threadId, deletedAt) {
+    const existing = this._byId.get(threadId);
+    if (existing && !existing.deletedAt) {
+      this.upsert({ ...existing, deletedAt, updatedAt: deletedAt });
+    }
+  }
+  /**
+   * Returns all threads matching a given roomId and query. If roomId is not
+   * specified, it will return all threads matching the query, across all
+   * rooms.
+   *
+   * Returns the results in the requested order. Please note:
+   *   'asc'  means by createdAt ASC
+   *   'desc' means by updatedAt DESC
+   *
+   * Will never return deleted threads in the result.
+   */
+  findMany(roomId, query, direction) {
+    const index = direction === "desc" ? this._desc : this._asc;
+    const crit = [];
+    if (roomId !== void 0) {
+      crit.push((t) => t.roomId === roomId);
+    }
+    crit.push(makeThreadsFilter(query));
+    return Array.from(index.filter((t) => crit.every((pred) => pred(t))));
+  }
+  //
+  // Private APIs
+  //
+  touch() {
+    ++this._version;
+  }
+};
+
 // src/umbrella-store.ts
-var ASYNC_OK = Object.freeze({ isLoading: false, data: void 0 });
 function makeRoomThreadsQueryKey(roomId, query) {
   return `${roomId}-${stringify(query ?? {})}`;
 }
@@ -102,19 +317,6 @@ function makeNotificationSettingsQueryKey(roomId) {
 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 query = options.query;
-  if (query) {
-    threads = threads.filter(makeThreadsFilter(query));
-  }
-  return threads.sort(
-    options.orderBy === "last-update" ? byMostRecentlyUpdated : byFirstCreated
-  );
-}
 function usify(promise) {
   if ("status" in promise) {
     return promise;
@@ -133,7 +335,7 @@ function usify(promise) {
   );
   return usable;
 }
-var noop = Promise.resolve();
+var noop2 = Promise.resolve();
 var ASYNC_LOADING = Object.freeze({ isLoading: true });
 var PaginatedResource = class {
   constructor(fetchPage) {
@@ -174,7 +376,7 @@ var PaginatedResource = class {
   fetchMore() {
     const state = this._paginationState;
     if (state?.cursor === null) {
-      return noop;
+      return noop2;
     }
     if (!this._pendingFetchMore) {
       this._pendingFetchMore = this._fetchMore().finally(() => {
@@ -237,8 +439,54 @@ var PaginatedResource = class {
     return promise;
   }
 };
+var SinglePageResource = class {
+  constructor(fetchPage) {
+    this._cachedPromise = null;
+    this._fetchPage = fetchPage;
+    this._eventSource = makeEventSource();
+    this.observable = this._eventSource.observable;
+    autobind(this);
+  }
+  get() {
+    const usable = this._cachedPromise;
+    if (usable === null || usable.status === "pending") {
+      return ASYNC_LOADING;
+    }
+    if (usable.status === "rejected") {
+      return { isLoading: false, error: usable.reason };
+    }
+    return {
+      isLoading: false,
+      data: void 0
+    };
+  }
+  waitUntilLoaded() {
+    if (this._cachedPromise) {
+      return this._cachedPromise;
+    }
+    const initialFetcher = autoRetry(
+      () => this._fetchPage(),
+      5,
+      [5e3, 5e3, 1e4, 15e3]
+    );
+    const promise = usify(initialFetcher);
+    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(client) {
+    this._prevVersion = -1;
     this._prevState = null;
     this._stateCached = null;
     // Notifications
@@ -249,16 +497,16 @@ var UmbrellaStore = class {
     // User Threads
     this._userThreadsLastRequestedAt = null;
     this._userThreads = /* @__PURE__ */ new Map();
+    // Room versions
+    this._roomVersions = /* @__PURE__ */ new Map();
+    this._roomVersionsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
+    // Room notification settings
+    this._roomNotificationSettings = /* @__PURE__ */ new Map();
+    this._client = client[kInternal].as();
     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 });
+      const result = await this._client.getInboxNotifications({ cursor });
       this.updateThreadsAndNotifications(
         result.threads,
-        // TODO: Figure out how to remove this casting
         result.inboxNotifications
       );
       if (this._notificationsLastRequestedAt === null) {
@@ -267,7 +515,6 @@ var UmbrellaStore = class {
       const nextCursor = result.nextCursor;
       return nextCursor;
     };
-    this._client = client;
     this._notifications = new PaginatedResource(inboxFetcher);
     this._notifications.observable.subscribe(
       () => (
@@ -276,10 +523,8 @@ var UmbrellaStore = class {
         this._store.set((store) => ({ ...store }))
       )
     );
+    this._rawThreadsDB = new ThreadDB();
     this._store = createStore({
-      rawThreadsById: {},
-      queries3: {},
-      queries4: {},
       optimisticUpdates: [],
       notificationsById: {},
       settingsByRoomId: {},
@@ -289,9 +534,11 @@ var UmbrellaStore = class {
   }
   get() {
     const rawState = this._store.get();
-    if (this._prevState !== rawState || this._stateCached === null) {
+    if (this._prevVersion !== this._rawThreadsDB.version || // Note: Version check is only needed temporarily, until we can get rid of the Zustand-like update model
+    this._prevState !== rawState || this._stateCached === null) {
+      this._stateCached = internalToExternalState(rawState, this._rawThreadsDB);
       this._prevState = rawState;
-      this._stateCached = internalToExternalState(rawState);
+      this._prevVersion = this._rawThreadsDB.version;
     }
     return this._stateCached;
   }
@@ -306,8 +553,7 @@ var UmbrellaStore = class {
    * then it will return the threads that match that provided query and room id.
    *
    */
-  // XXXX Find a better name for that doesn't associate to 'async'
-  getRoomThreadsAsync(roomId, query) {
+  getRoomThreadsLoadingState(roomId, query) {
     const queryKey = makeRoomThreadsQueryKey(roomId, query);
     const paginatedResource = this._roomThreads.get(queryKey);
     if (paginatedResource === void 0) {
@@ -317,11 +563,11 @@ var UmbrellaStore = class {
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
     }
-    const threads = selectThreads(this.getFullState(), {
+    const threads = this.getFullState().threadsDB.findMany(
       roomId,
-      query,
-      orderBy: "age"
-    });
+      query ?? {},
+      "asc"
+    );
     const page = asyncResult.data;
     return {
       isLoading: false,
@@ -332,8 +578,7 @@ var UmbrellaStore = class {
       fetchMore: page.fetchMore
     };
   }
-  // XXXX - Find a better name for that doesn't associate to 'async'
-  getUserThreadsAsync(query) {
+  getUserThreadsLoadingState(query) {
     const queryKey = makeUserThreadsQueryKey(query);
     const paginatedResource = this._userThreads.get(queryKey);
     if (paginatedResource === void 0) {
@@ -343,12 +588,12 @@ var UmbrellaStore = class {
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
     }
-    const threads = selectThreads(this.getFullState(), {
-      roomId: null,
+    const threads = this.getFullState().threadsDB.findMany(
+      void 0,
       // Do _not_ filter by roomId
-      query,
-      orderBy: "last-update"
-    });
+      query ?? {},
+      "desc"
+    );
     const page = asyncResult.data;
     return {
       isLoading: false,
@@ -360,8 +605,7 @@ var UmbrellaStore = class {
     };
   }
   // 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() {
+  getInboxNotificationsLoadingState() {
     const asyncResult = this._notifications.get();
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
@@ -369,7 +613,7 @@ var UmbrellaStore = class {
     const page = asyncResult.data;
     return {
       isLoading: false,
-      inboxNotifications: this.getFullState().notifications,
+      inboxNotifications: this.getFullState().cleanedNotifications,
       hasFetchedAll: page.hasFetchedAll,
       isFetchingMore: page.isFetchingMore,
       fetchMoreError: page.fetchMoreError,
@@ -377,32 +621,34 @@ var UmbrellaStore = class {
     };
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
-  getNotificationSettingsAsync(roomId) {
-    const state = this.get();
-    const query = state.queries3[makeNotificationSettingsQueryKey(roomId)];
-    if (query === void 0 || query.isLoading) {
+  getNotificationSettingsLoadingState(roomId) {
+    const queryKey = makeNotificationSettingsQueryKey(roomId);
+    const resource = this._roomNotificationSettings.get(queryKey);
+    if (resource === void 0) {
       return ASYNC_LOADING;
     }
-    if (query.error !== void 0) {
-      return query;
+    const asyncResult = resource.get();
+    if (asyncResult.isLoading || asyncResult.error) {
+      return asyncResult;
     }
     return {
       isLoading: false,
-      settings: nn(state.settingsByRoomId[roomId])
+      settings: nn(this.get().settingsByRoomId[roomId])
     };
   }
-  getVersionsAsync(roomId) {
-    const state = this.get();
-    const query = state.queries4[makeVersionsQueryKey(roomId)];
-    if (query === void 0 || query.isLoading) {
+  getRoomVersionsLoadingState(roomId) {
+    const queryKey = makeVersionsQueryKey(roomId);
+    const resource = this._roomVersions.get(queryKey);
+    if (resource === void 0) {
       return ASYNC_LOADING;
     }
-    if (query.error !== void 0) {
-      return query;
+    const asyncResult = resource.get();
+    if (asyncResult.isLoading || asyncResult.error) {
+      return asyncResult;
     }
     return {
       isLoading: false,
-      versions: nn(state.versionsByRoomId[roomId])
+      versions: Object.values(this.get().versionsByRoomId[roomId] ?? {})
     };
   }
   /**
@@ -414,33 +660,14 @@ var UmbrellaStore = class {
   subscribe(callback) {
     return this._store.subscribe(callback);
   }
-  /**
-   * @private Only used by the E2E test suite.
-   */
-  _subscribeOptimisticUpdates(callback) {
-    return this.subscribe(callback);
-  }
-  subscribeThreads(callback) {
-    return this.subscribe(callback);
-  }
-  subscribeUserThreads(callback) {
-    return this.subscribe(callback);
-  }
-  subscribeThreadsOrInboxNotifications(callback) {
-    return this.subscribe(callback);
-  }
-  subscribeNotificationSettings(callback) {
-    return this.subscribe(callback);
-  }
-  subscribeVersions(callback) {
-    return this.subscribe(callback);
-  }
   // Direct low-level cache mutations ------------------------------------------------- {{{
-  updateThreadsCache(mapFn) {
-    this._store.set((state) => {
-      const threads = mapFn(state.rawThreadsById);
-      return threads !== state.rawThreadsById ? { ...state, rawThreadsById: threads } : state;
-    });
+  mutateThreadsDB(mutate) {
+    const db = this._rawThreadsDB;
+    const old = db.version;
+    mutate(db);
+    if (old !== db.version) {
+      this._store.set((state) => ({ ...state }));
+    }
   }
   updateInboxNotificationsCache(mapFn) {
     this._store.set((state) => {
@@ -457,32 +684,23 @@ var UmbrellaStore = class {
       }
     }));
   }
-  setVersions(roomId, versions) {
-    this._store.set((state) => ({
-      ...state,
-      versionsByRoomId: {
-        ...state.versionsByRoomId,
-        [roomId]: versions
-      }
-    }));
-  }
-  setQuery3State(queryKey, queryState) {
-    this._store.set((state) => ({
-      ...state,
-      queries3: {
-        ...state.queries3,
-        [queryKey]: queryState
-      }
-    }));
-  }
-  setQuery4State(queryKey, queryState) {
-    this._store.set((state) => ({
-      ...state,
-      queries4: {
-        ...state.queries4,
-        [queryKey]: queryState
-      }
-    }));
+  updateRoomVersions(roomId, versions) {
+    this._store.set((state) => {
+      const versionsById = Object.fromEntries(
+        versions.map((version2) => [version2.id, version2])
+      );
+      return {
+        ...state,
+        versionsByRoomId: {
+          ...state.versionsByRoomId,
+          [roomId]: {
+            // Merge with existing versions for the room, or start with an empty object
+            ...state.versionsByRoomId[roomId] ?? {},
+            ...versionsById
+          }
+        }
+      };
+    });
   }
   updateOptimisticUpdatesCache(mapFn) {
     this._store.set((state) => ({
@@ -557,7 +775,7 @@ var UmbrellaStore = class {
   createThread(optimisticUpdateId, thread) {
     this._store.batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateThreadsCache((cache) => ({ ...cache, [thread.id]: thread }));
+      this.mutateThreadsDB((db) => db.upsert(thread));
     });
   }
   /**
@@ -575,18 +793,11 @@ var UmbrellaStore = class {
       if (optimisticUpdateId !== null) {
         this.removeOptimisticUpdate(optimisticUpdateId);
       }
-      this.updateThreadsCache((cache) => {
-        const existing = cache[threadId];
-        if (!existing) {
-          return cache;
-        }
-        if (existing.deletedAt !== void 0) {
-          return cache;
-        }
-        if (!!updatedAt && existing.updatedAt > updatedAt) {
-          return cache;
-        }
-        return { ...cache, [threadId]: callback(existing) };
+      this.mutateThreadsDB((db) => {
+        const existing = db.get(threadId);
+        if (!existing) return;
+        if (!!updatedAt && existing.updatedAt > updatedAt) return;
+        db.upsert(callback(existing));
       });
     });
   }
@@ -637,14 +848,13 @@ var UmbrellaStore = class {
   createComment(newComment, optimisticUpdateId) {
     this._store.batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      const existingThread = this._store.get().rawThreadsById[newComment.threadId];
+      const existingThread = this._rawThreadsDB.get(newComment.threadId);
       if (!existingThread) {
         return;
       }
-      this.updateThreadsCache((cache) => ({
-        ...cache,
-        [newComment.threadId]: applyUpsertComment(existingThread, newComment)
-      }));
+      this.mutateThreadsDB(
+        (db) => db.upsert(applyUpsertComment(existingThread, newComment))
+      );
       this.updateInboxNotificationsCache((cache) => {
         const existingNotification = Object.values(cache).find(
           (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
@@ -680,10 +890,7 @@ var UmbrellaStore = class {
   }
   updateThreadAndNotification(thread, inboxNotification) {
     this._store.batch(() => {
-      this.updateThreadsCache((cache) => {
-        const existingThread = cache[thread.id];
-        return existingThread === void 0 || isMoreRecentlyUpdated(thread, existingThread) ? { ...cache, [thread.id]: thread } : cache;
-      });
+      this.mutateThreadsDB((db) => db.upsertIfNewer(thread));
       if (inboxNotification !== void 0) {
         this.updateInboxNotificationsCache((cache) => ({
           ...cache,
@@ -694,11 +901,8 @@ var UmbrellaStore = class {
   }
   updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
     this._store.batch(() => {
-      this.updateThreadsCache(
-        (cache) => applyThreadUpdates(cache, {
-          newThreads: threads,
-          deletedThreads
-        })
+      this.mutateThreadsDB(
+        (db) => applyThreadDeltaUpdates(db, { newThreads: threads, deletedThreads })
       );
       this.updateInboxNotificationsCache(
         (cache) => applyNotificationsUpdates(cache, {
@@ -712,28 +916,12 @@ 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) {
+  updateRoomNotificationSettings_confirmOptimisticUpdate(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);
-      this.setNotificationSettings(roomId, settings);
-    });
-  }
-  updateRoomVersions(roomId, versions, queryKey) {
-    this._store.batch(() => {
-      this.setVersions(roomId, versions);
-      if (queryKey !== void 0) {
-        this.setQuery4OK(queryKey);
-      }
-    });
-  }
   addOptimisticUpdate(optimisticUpdate) {
     const id = nanoid();
     const newUpdate = { ...optimisticUpdate, id };
@@ -745,36 +933,15 @@ var UmbrellaStore = class {
       (cache) => cache.filter((ou) => ou.id !== optimisticUpdateId)
     );
   }
-  // Query 3
-  setQuery3Loading(queryKey) {
-    this.setQuery3State(queryKey, ASYNC_LOADING);
-  }
-  setQuery3OK(queryKey) {
-    this.setQuery3State(queryKey, ASYNC_OK);
-  }
-  setQuery3Error(queryKey, error) {
-    this.setQuery3State(queryKey, { isLoading: false, error });
-  }
-  // Query 4
-  setQuery4Loading(queryKey) {
-    this.setQuery4State(queryKey, ASYNC_LOADING);
-  }
-  setQuery4OK(queryKey) {
-    this.setQuery4State(queryKey, ASYNC_OK);
-  }
-  setQuery4Error(queryKey, error) {
-    this.setQuery4State(queryKey, { isLoading: false, error });
-  }
-  async fetchNotificationsDeltaUpdate() {
+  async fetchNotificationsDeltaUpdate(signal) {
     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);
+    const result = await this._client.getInboxNotificationsSince({
+      since: lastRequestedAt,
+      signal
+    });
     if (lastRequestedAt < result.requestedAt) {
       this._notificationsLastRequestedAt = result.requestedAt;
     }
@@ -790,21 +957,13 @@ var UmbrellaStore = class {
   }
   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`
-        );
+        throw new HttpError(`Room '${roomId}' is not available on client`, 479);
       }
       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);
@@ -828,21 +987,18 @@ var UmbrellaStore = class {
     this._roomThreads.set(queryKey, paginatedResource);
     return paginatedResource.waitUntilLoaded();
   }
-  async fetchRoomThreadsDeltaUpdate(roomId) {
+  async fetchRoomThreadsDeltaUpdate(roomId, signal) {
     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),
+      this._client.getRoom(roomId),
       `Room with id ${roomId} is not available on client`
     );
     const updates = await room.getThreadsSince({
-      since: lastRequestedAt
+      since: lastRequestedAt,
+      signal
     });
     this.updateThreadsAndNotifications(
       updates.threads.updated,
@@ -857,18 +1013,12 @@ var UmbrellaStore = class {
   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) {
@@ -890,17 +1040,14 @@ var UmbrellaStore = class {
     this._userThreads.set(queryKey, paginatedResource);
     return paginatedResource.waitUntilLoaded();
   }
-  async fetchUserThreadsDeltaUpdate() {
+  async fetchUserThreadsDeltaUpdate(signal) {
     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
+    const result = await this._client[kInternal].getUserThreadsSince_experimental({
+      since: lastRequestedAt,
+      signal
     });
     if (lastRequestedAt < result.requestedAt) {
       this._notificationsLastRequestedAt = result.requestedAt;
@@ -912,77 +1059,138 @@ var UmbrellaStore = class {
       result.inboxNotifications.deleted
     );
   }
+  waitUntilRoomVersionsLoaded(roomId) {
+    const queryKey = makeVersionsQueryKey(roomId);
+    let resource = this._roomVersions.get(queryKey);
+    if (resource === void 0) {
+      const versionsFetcher = async () => {
+        const room = this._client.getRoom(roomId);
+        if (room === null) {
+          throw new HttpError(
+            `Room '${roomId}' is not available on client`,
+            479
+          );
+        }
+        const result = await room[kInternal].listTextVersions();
+        this.updateRoomVersions(roomId, result.versions);
+        const lastRequestedAt = this._roomVersionsLastRequestedAtByRoom.get(roomId);
+        if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
+          this._roomVersionsLastRequestedAtByRoom.set(
+            roomId,
+            result.requestedAt
+          );
+        }
+      };
+      resource = new SinglePageResource(versionsFetcher);
+    }
+    resource.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._roomVersions.set(queryKey, resource);
+    return resource.waitUntilLoaded();
+  }
+  async fetchRoomVersionsDeltaUpdate(roomId, signal) {
+    const lastRequestedAt = this._roomVersionsLastRequestedAtByRoom.get(roomId);
+    if (lastRequestedAt === void 0) {
+      return;
+    }
+    const room = nn(
+      this._client.getRoom(roomId),
+      `Room with id ${roomId} is not available on client`
+    );
+    const updates = await room[kInternal].listTextVersionsSince({
+      since: lastRequestedAt,
+      signal
+    });
+    this.updateRoomVersions(roomId, updates.versions);
+    if (lastRequestedAt < updates.requestedAt) {
+      this._roomVersionsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
+    }
+  }
+  waitUntilRoomNotificationSettingsLoaded(roomId) {
+    const queryKey = makeNotificationSettingsQueryKey(roomId);
+    let resource = this._roomNotificationSettings.get(queryKey);
+    if (resource === void 0) {
+      const notificationSettingsFetcher = async () => {
+        const room = this._client.getRoom(roomId);
+        if (room === null) {
+          throw new HttpError(
+            `Room '${roomId}' is not available on client`,
+            479
+          );
+        }
+        const result = await room.getNotificationSettings();
+        this.setNotificationSettings(roomId, result);
+      };
+      resource = new SinglePageResource(notificationSettingsFetcher);
+    }
+    resource.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._roomNotificationSettings.set(queryKey, resource);
+    return resource.waitUntilLoaded();
+  }
+  async refreshRoomNotificationSettings(roomId, signal) {
+    const room = nn(
+      this._client.getRoom(roomId),
+      `Room with id ${roomId} is not available on client`
+    );
+    const result = await room.getNotificationSettings({ signal });
+    this.setNotificationSettings(roomId, result);
+  }
 };
-function internalToExternalState(state) {
+function internalToExternalState(state, rawThreadsDB) {
+  const threadsDB = rawThreadsDB.clone();
   const computed = {
-    threadsById: { ...state.rawThreadsById },
     notificationsById: { ...state.notificationsById },
     settingsByRoomId: { ...state.settingsByRoomId }
   };
   for (const optimisticUpdate of state.optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "create-thread": {
-        computed.threadsById[optimisticUpdate.thread.id] = optimisticUpdate.thread;
+        threadsDB.upsert(optimisticUpdate.thread);
         break;
       }
       case "edit-thread-metadata": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        if (thread.deletedAt !== void 0) {
-          break;
-        }
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
         if (thread.updatedAt > optimisticUpdate.updatedAt) {
           break;
         }
-        computed.threadsById[thread.id] = {
+        threadsDB.upsert({
           ...thread,
           updatedAt: optimisticUpdate.updatedAt,
           metadata: {
             ...thread.metadata,
             ...optimisticUpdate.metadata
           }
-        };
+        });
         break;
       }
       case "mark-thread-as-resolved": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        if (thread.deletedAt !== void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = {
-          ...thread,
-          resolved: true
-        };
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert({ ...thread, resolved: true });
         break;
-      }
-      case "mark-thread-as-unresolved": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        if (thread.deletedAt !== void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = {
-          ...thread,
-          resolved: false
-        };
+      }
+      case "mark-thread-as-unresolved": {
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert({ ...thread, resolved: false });
         break;
       }
       case "create-comment": {
-        const thread = computed.threadsById[optimisticUpdate.comment.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = applyUpsertComment(
-          thread,
-          optimisticUpdate.comment
-        );
+        const thread = threadsDB.get(optimisticUpdate.comment.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert(applyUpsertComment(thread, optimisticUpdate.comment));
         const inboxNotification = Object.values(
           computed.notificationsById
         ).find(
@@ -999,64 +1207,57 @@ function internalToExternalState(state) {
         break;
       }
       case "edit-comment": {
-        const thread = computed.threadsById[optimisticUpdate.comment.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = applyUpsertComment(
-          thread,
-          optimisticUpdate.comment
-        );
+        const thread = threadsDB.get(optimisticUpdate.comment.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert(applyUpsertComment(thread, optimisticUpdate.comment));
         break;
       }
       case "delete-comment": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = applyDeleteComment(
-          thread,
-          optimisticUpdate.commentId,
-          optimisticUpdate.deletedAt
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert(
+          applyDeleteComment(
+            thread,
+            optimisticUpdate.commentId,
+            optimisticUpdate.deletedAt
+          )
         );
         break;
       }
       case "delete-thread": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[optimisticUpdate.threadId] = {
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert({
           ...thread,
           deletedAt: optimisticUpdate.deletedAt,
           updatedAt: optimisticUpdate.deletedAt,
           comments: []
-        };
+        });
         break;
       }
       case "add-reaction": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = applyAddReaction(
-          thread,
-          optimisticUpdate.commentId,
-          optimisticUpdate.reaction
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert(
+          applyAddReaction(
+            thread,
+            optimisticUpdate.commentId,
+            optimisticUpdate.reaction
+          )
         );
         break;
       }
       case "remove-reaction": {
-        const thread = computed.threadsById[optimisticUpdate.threadId];
-        if (thread === void 0) {
-          break;
-        }
-        computed.threadsById[thread.id] = applyRemoveReaction(
-          thread,
-          optimisticUpdate.commentId,
-          optimisticUpdate.emoji,
-          optimisticUpdate.userId,
-          optimisticUpdate.removedAt
+        const thread = threadsDB.get(optimisticUpdate.threadId);
+        if (thread === void 0) break;
+        threadsDB.upsert(
+          applyRemoveReaction(
+            thread,
+            optimisticUpdate.commentId,
+            optimisticUpdate.emoji,
+            optimisticUpdate.userId,
+            optimisticUpdate.removedAt
+          )
         );
         break;
       }
@@ -1104,51 +1305,27 @@ function internalToExternalState(state) {
       }
     }
   }
-  const cleanedThreads = (
-    // Don't expose any soft-deleted threads
-    Object.values(computed.threadsById).filter((thread) => !thread.deletedAt).filter(
-      (thread) => (
-        // Only keep a thread if there is at least one non-deleted comment
-        thread.comments.some((c) => c.deletedAt === void 0)
-      )
-    )
-  );
   const cleanedNotifications = (
     // Sort so that the most recent notifications are first
     Object.values(computed.notificationsById).filter(
-      (ibn) => ibn.kind === "thread" ? computed.threadsById[ibn.threadId] && computed.threadsById[ibn.threadId]?.deletedAt === void 0 : true
+      (ibn) => ibn.kind === "thread" ? threadsDB.get(ibn.threadId) !== void 0 : true
     ).sort((a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime())
   );
   return {
-    notifications: cleanedNotifications,
+    cleanedNotifications,
     notificationsById: computed.notificationsById,
     settingsByRoomId: computed.settingsByRoomId,
-    queries3: state.queries3,
-    queries4: state.queries4,
-    threads: cleanedThreads,
-    threadsById: computed.threadsById,
+    threadsDB,
     versionsByRoomId: state.versionsByRoomId
   };
 }
-function applyThreadUpdates(existingThreads, updates) {
-  const updatedThreads = { ...existingThreads };
-  updates.newThreads.forEach((thread) => {
-    const existingThread = updatedThreads[thread.id];
-    if (existingThread) {
-      if (isMoreRecentlyUpdated(existingThread, thread)) {
-        return;
-      }
-    }
-    updatedThreads[thread.id] = thread;
-  });
+function applyThreadDeltaUpdates(db, updates) {
+  updates.newThreads.forEach((thread) => db.upsertIfNewer(thread));
   updates.deletedThreads.forEach(({ id, deletedAt }) => {
-    const existingThread = updatedThreads[id];
-    if (existingThread === void 0) return;
-    existingThread.deletedAt = deletedAt;
-    existingThread.updatedAt = deletedAt;
-    existingThread.comments = [];
+    const existing = db.getEvenIfDeleted(id);
+    if (!existing) return;
+    db.delete(id, deletedAt);
   });
-  return updatedThreads;
 }
 function applyNotificationsUpdates(existingInboxNotifications, updates) {
   const updatedInboxNotifications = { ...existingInboxNotifications };
@@ -1346,97 +1523,6 @@ function upsertReaction(reactions, reaction) {
   return reactions;
 }
 
-// src/liveblocks.tsx
-import {
-  assert,
-  createClient,
-  kInternal as kInternal2,
-  makePoller,
-  raise,
-  shallow as shallow3
-} from "@liveblocks/core";
-import React2, {
-  createContext as createContext2,
-  useCallback as useCallback2,
-  useContext as useContext2,
-  useEffect as useEffect2,
-  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, useRef } from "react";
-function useLatest(value) {
-  const ref = useRef(value);
-  useEffect(() => {
-    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) {
@@ -1453,7 +1539,6 @@ function identity(x) {
 var _umbrellaStores = /* @__PURE__ */ new WeakMap();
 var _extras = /* @__PURE__ */ new WeakMap();
 var _bundles = /* @__PURE__ */ new WeakMap();
-var POLLING_INTERVAL = 60 * 1e3;
 function selectUnreadInboxNotificationsCount(inboxNotifications) {
   let count = 0;
   for (const notification of inboxNotifications) {
@@ -1532,61 +1617,36 @@ function getLiveblocksExtrasForClient(client) {
   }
   return extras;
 }
-function makeDeltaPoller_Notifications(store) {
-  const poller = makePoller(async () => {
-    try {
-      await store.waitUntilNotificationsLoaded();
-      await store.fetchNotificationsDeltaUpdate();
-    } catch (err) {
-      console.warn(`Polling new inbox notifications failed: ${String(err)}`);
-    }
-  }, POLLING_INTERVAL);
-  let pollerSubscribers = 0;
-  return () => {
-    pollerSubscribers++;
-    poller.enable(pollerSubscribers > 0);
-    return () => {
-      pollerSubscribers--;
-      poller.enable(pollerSubscribers > 0);
-    };
-  };
-}
-function makeDeltaPoller_UserThreads(store) {
-  const poller = makePoller(async () => {
-    try {
-      await store.fetchUserThreadsDeltaUpdate();
-    } catch (err) {
-      console.warn(`Polling new user threads failed: ${String(err)}`);
-    }
-  }, POLLING_INTERVAL);
-  let pollerSubscribers = 0;
-  return () => {
-    pollerSubscribers++;
-    poller.enable(pollerSubscribers > 0);
-    return () => {
-      pollerSubscribers--;
-      poller.enable(pollerSubscribers > 0);
-    };
-  };
-}
 function makeLiveblocksExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
+  const notificationsPoller = makePoller(
+    async (signal) => {
+      try {
+        return await store.fetchNotificationsDeltaUpdate(signal);
+      } catch (err) {
+        console.warn(`Polling new inbox notifications failed: ${String(err)}`);
+        throw err;
+      }
+    },
+    config.NOTIFICATIONS_POLL_INTERVAL,
+    { maxStaleTimeMs: config.NOTIFICATIONS_MAX_STALE_TIME }
+  );
+  const userThreadsPoller = makePoller(
+    async (signal) => {
+      try {
+        return await store.fetchUserThreadsDeltaUpdate(signal);
+      } catch (err) {
+        console.warn(`Polling new user threads failed: ${String(err)}`);
+        throw err;
+      }
+    },
+    config.USER_THREADS_POLL_INTERVAL,
+    { maxStaleTimeMs: config.USER_THREADS_MAX_STALE_TIME }
+  );
   return {
     store,
-    /**
-     * 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)
+    notificationsPoller,
+    userThreadsPoller
   };
 }
 function makeLiveblocksContextBundle(client) {
@@ -1627,19 +1687,21 @@ function makeLiveblocksContextBundle(client) {
   return bundle;
 }
 function useInboxNotifications_withClient(client, selector, isEqual) {
-  const {
-    store,
-    subscribeToNotificationsDeltaUpdates: subscribeToDeltaUpdates
-  } = getLiveblocksExtrasForClient(client);
+  const { store, notificationsPoller: poller } = getLiveblocksExtrasForClient(client);
   useEffect2(() => {
-    void store.waitUntilNotificationsLoaded().catch(() => {
-    });
+    void store.waitUntilNotificationsLoaded();
   });
-  useEffect2(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  useEffect2(() => {
+    poller.inc();
+    poller.pollNowIfStale();
+    return () => {
+      poller.dec();
+    };
+  }, [poller]);
   return useSyncExternalStoreWithSelector(
-    store.subscribeThreadsOrInboxNotifications,
-    store.getInboxNotificationsAsync,
-    store.getInboxNotificationsAsync,
+    store.subscribe,
+    store.getInboxNotificationsLoadingState,
+    store.getInboxNotificationsLoadingState,
     selector,
     isEqual
   );
@@ -1768,7 +1830,7 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
           `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
         );
       }
-      const thread = state.threadsById[inboxNotification.threadId] ?? raise(
+      const thread = state.threadsDB.get(inboxNotification.threadId) ?? raise(
         `Thread with ID "${inboxNotification.threadId}" not found, this inbox notification might not be of kind "thread"`
       );
       return thread;
@@ -1776,7 +1838,7 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
     [inboxNotificationId]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribeThreadsOrInboxNotifications,
+    store.subscribe,
     // Re-evaluate if we need to update any time the notification changes over time
     getter,
     getter,
@@ -1960,11 +2022,10 @@ function useUserThreads_experimental(options = {
   }
 }) {
   const client = useClient();
-  const { store, subscribeToUserThreadsDeltaUpdates: subscribeToDeltaUpdates } = getLiveblocksExtrasForClient(client);
+  const { store, userThreadsPoller: poller } = getLiveblocksExtrasForClient(client);
   useEffect2(
     () => {
-      void store.waitUntilUserThreadsLoaded(options.query).catch(() => {
-      });
+      void store.waitUntilUserThreadsLoaded(options.query);
     }
     // NOTE: Deliberately *not* using a dependency array here!
     //
@@ -1975,13 +2036,19 @@ function useUserThreads_experimental(options = {
     // 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.
   );
-  useEffect2(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  useEffect2(() => {
+    poller.inc();
+    poller.pollNowIfStale();
+    return () => {
+      poller.dec();
+    };
+  }, [poller]);
   const getter = useCallback2(
-    () => store.getUserThreadsAsync(options.query),
+    () => store.getUserThreadsLoadingState(options.query),
     [store, options.query]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribeUserThreads,
+    store.subscribe,
     getter,
     getter,
     identity,
@@ -2154,32 +2221,20 @@ var UpdateNotificationSettingsError = class extends Error {
 import { shallow as shallow4 } from "@liveblocks/client";
 import {
   assert as assert2,
-  CommentsApiError,
   console as console3,
   createCommentId,
   createThreadId,
   deprecateIf,
   errorIf,
+  HttpError as HttpError2,
   kInternal as kInternal3,
   makeEventSource as makeEventSource2,
   makePoller as makePoller2,
-  NotificationsApiError,
   ServerMsgCode
 } from "@liveblocks/core";
 import * as React4 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 React3 from "react";
 function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
@@ -2230,7 +2285,6 @@ function useSyncExternalStore2(s, gs, gss) {
   return useSyncExternalStoreWithSelector2(s, gs, gss, identity2);
 }
 var STABLE_EMPTY_LIST = Object.freeze([]);
-var POLLING_INTERVAL2 = 5 * 60 * 1e3;
 function alwaysEmptyList() {
   return STABLE_EMPTY_LIST;
 }
@@ -2285,28 +2339,6 @@ 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) {
@@ -2327,78 +2359,87 @@ function getRoomExtrasForClient(client) {
 }
 function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
-  const requestsByQuery = /* @__PURE__ */ new Map();
-  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[kInternal3].listTextVersions();
-    requestsByQuery.set(queryKey, request);
-    store.setQuery4Loading(queryKey);
-    try {
-      const result = await request;
-      const data = await result.json();
-      const versions = data.versions.map(({ createdAt, ...version2 }) => {
-        return {
-          createdAt: new Date(createdAt),
-          ...version2
-        };
-      });
-      store.updateRoomVersions(room.id, versions, queryKey);
-      requestsByQuery.delete(queryKey);
-    } catch (err) {
-      requestsByQuery.delete(queryKey);
-      retryError(() => {
-        void getRoomVersions(room, {
-          retryCount: retryCount + 1
-        });
-      }, retryCount);
-      store.setQuery4Error(queryKey, err);
-    }
-    return;
-  }
-  async function getInboxNotificationSettings(room, { retryCount } = { retryCount: 0 }) {
-    const queryKey = makeNotificationSettingsQueryKey(room.id);
-    const existingRequest = requestsByQuery.get(queryKey);
-    if (existingRequest !== void 0) return existingRequest;
-    try {
-      const request = room.getNotificationSettings();
-      requestsByQuery.set(queryKey, request);
-      store.setQuery3Loading(queryKey);
-      const settings = await request;
-      store.updateRoomInboxNotificationSettings(room.id, settings, queryKey);
-    } catch (err) {
-      requestsByQuery.delete(queryKey);
-      retryError(() => {
-        void getInboxNotificationSettings(room, {
-          retryCount: retryCount + 1
-        });
-      }, retryCount);
-      store.setQuery3Error(queryKey, err);
-    }
-    return;
-  }
   const commentsErrorEventSource = makeEventSource2();
   function onMutationFailure(innerError, optimisticUpdateId, createPublicError) {
     store.removeOptimisticUpdate(optimisticUpdateId);
-    if (innerError instanceof CommentsApiError) {
+    if (innerError instanceof HttpError2) {
       const error = handleApiError(innerError);
       commentsErrorEventSource.notify(createPublicError(error));
       return;
     }
-    if (innerError instanceof NotificationsApiError) {
+    if (innerError instanceof HttpError2) {
       handleApiError(innerError);
       return;
     }
     throw innerError;
   }
+  const threadsPollersByRoomId = /* @__PURE__ */ new Map();
+  const versionsPollersByRoomId = /* @__PURE__ */ new Map();
+  const roomNotificationSettingsPollersByRoomId = /* @__PURE__ */ new Map();
+  function getOrCreateThreadsPollerForRoomId(roomId) {
+    let poller = threadsPollersByRoomId.get(roomId);
+    if (!poller) {
+      poller = makePoller2(
+        async (signal) => {
+          try {
+            return await store.fetchRoomThreadsDeltaUpdate(roomId, signal);
+          } catch (err) {
+            console3.warn(`Polling new threads for '${roomId}' failed: ${String(err)}`);
+            throw err;
+          }
+        },
+        config.ROOM_THREADS_POLL_INTERVAL,
+        { maxStaleTimeMs: config.ROOM_THREADS_MAX_STALE_TIME }
+      );
+      threadsPollersByRoomId.set(roomId, poller);
+    }
+    return poller;
+  }
+  function getOrCreateVersionsPollerForRoomId(roomId) {
+    let poller = versionsPollersByRoomId.get(roomId);
+    if (!poller) {
+      poller = makePoller2(
+        async (signal) => {
+          try {
+            return await store.fetchRoomVersionsDeltaUpdate(roomId, signal);
+          } catch (err) {
+            console3.warn(`Polling new history versions for '${roomId}' failed: ${String(err)}`);
+            throw err;
+          }
+        },
+        config.HISTORY_VERSIONS_POLL_INTERVAL,
+        { maxStaleTimeMs: config.HISTORY_VERSIONS_MAX_STALE_TIME }
+      );
+      versionsPollersByRoomId.set(roomId, poller);
+    }
+    return poller;
+  }
+  function getOrCreateNotificationsSettingsPollerForRoomId(roomId) {
+    let poller = roomNotificationSettingsPollersByRoomId.get(roomId);
+    if (!poller) {
+      poller = makePoller2(
+        async (signal) => {
+          try {
+            return await store.refreshRoomNotificationSettings(roomId, signal);
+          } catch (err) {
+            console3.warn(`Polling notification settings for '${roomId}' failed: ${String(err)}`);
+            throw err;
+          }
+        },
+        config.NOTIFICATION_SETTINGS_POLL_INTERVAL,
+        { maxStaleTimeMs: config.NOTIFICATION_SETTINGS_MAX_STALE_TIME }
+      );
+      roomNotificationSettingsPollersByRoomId.set(roomId, poller);
+    }
+    return poller;
+  }
   return {
     store,
-    subscribeToRoomThreadsDeltaUpdates: makeDeltaPoller_RoomThreads(client),
-    commentsErrorEventSource,
-    getInboxNotificationSettings,
-    getRoomVersions,
-    onMutationFailure
+    commentsErrorEventSource: commentsErrorEventSource.observable,
+    onMutationFailure,
+    getOrCreateThreadsPollerForRoomId,
+    getOrCreateVersionsPollerForRoomId,
+    getOrCreateNotificationsSettingsPollerForRoomId
   };
 }
 function makeRoomContextBundle(client) {
@@ -2582,7 +2623,7 @@ function RoomProviderInner(props) {
         return;
       }
       const { thread, inboxNotification } = info;
-      const existingThread = store.getFullState().threadsById[message.threadId];
+      const existingThread = store.getFullState().threadsDB.getEvenIfDeleted(message.threadId);
       switch (message.type) {
         case ServerMsgCode.COMMENT_EDITED:
         case ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -2604,22 +2645,6 @@ function RoomProviderInner(props) {
       (message) => void handleCommentEvent(message)
     );
   }, [client, room]);
-  React4.useEffect(() => {
-    const store = getRoomExtrasForClient(client).store;
-    void store.fetchRoomThreadsDeltaUpdate(room.id).catch(() => {
-    });
-  }, [client, room.id]);
-  React4.useEffect(() => {
-    function handleIsOnline() {
-      const store = getRoomExtrasForClient(client).store;
-      void store.fetchRoomThreadsDeltaUpdate(room.id).catch(() => {
-      });
-    }
-    window.addEventListener("online", handleIsOnline);
-    return () => {
-      window.removeEventListener("online", handleIsOnline);
-    };
-  }, [client, room.id]);
   React4.useEffect(() => {
     const pair = stableEnterRoom(roomId, frozenProps);
     setRoomLeavePair(pair);
@@ -2907,11 +2932,11 @@ function useThreads(options = {
   const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
-  const { store, subscribeToRoomThreadsDeltaUpdates: subscribeToDeltaUpdates } = getRoomExtrasForClient(client);
+  const { store, getOrCreateThreadsPollerForRoomId } = getRoomExtrasForClient(client);
+  const poller = getOrCreateThreadsPollerForRoomId(room.id);
   React4.useEffect(
     () => {
-      void store.waitUntilRoomThreadsLoaded(room.id, options.query).catch(() => {
-      });
+      void store.waitUntilRoomThreadsLoaded(room.id, options.query);
     }
     // NOTE: Deliberately *not* using a dependency array here!
     //
@@ -2922,13 +2947,17 @@ function useThreads(options = {
     // 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.
   );
-  React4.useEffect(subscribeToDeltaUpdates, [subscribeToDeltaUpdates]);
+  React4.useEffect(() => {
+    poller.inc();
+    poller.pollNowIfStale();
+    return () => poller.dec();
+  }, [poller]);
   const getter = React4.useCallback(
-    () => store.getRoomThreadsAsync(room.id, options.query),
+    () => store.getRoomThreadsLoadingState(room.id, options.query),
     [store, room.id, options.query]
   );
   const state = useSyncExternalStoreWithSelector2(
-    store.subscribeThreads,
+    store.subscribe,
     getter,
     getter,
     identity2,
@@ -3012,9 +3041,9 @@ function useDeleteThread() {
   return React4.useCallback(
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const thread = store.getFullState().threadsById[threadId];
       const userId = getCurrentUserId(room);
-      if (thread?.comments?.[0]?.userId !== userId) {
+      const existing = store.getFullState().threadsDB.get(threadId);
+      if (existing?.comments?.[0]?.userId !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
       const optimisticUpdateId = store.addOptimisticUpdate({
@@ -3130,14 +3159,14 @@ function useEditComment() {
     ({ threadId, commentId, body, attachments }) => {
       const editedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const thread = store.getFullState().threadsById[threadId];
-      if (thread === void 0) {
+      const existing = store.getFullState().threadsDB.getEvenIfDeleted(threadId);
+      if (existing === void 0) {
         console3.warn(
           `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
         );
         return;
       }
-      const comment = thread.comments.find(
+      const comment = existing.comments.find(
         (comment2) => comment2.id === commentId
       );
       if (comment === void 0 || comment.deletedAt !== void 0) {
@@ -3411,24 +3440,22 @@ function useThreadSubscription(threadId) {
   const { store } = getRoomExtrasForClient(client);
   const selector = React4.useCallback(
     (state) => {
-      const inboxNotification = state.notifications.find(
-        (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
+      const notification = state.cleanedNotifications.find(
+        (inboxNotification) => inboxNotification.kind === "thread" && inboxNotification.threadId === threadId
       );
-      const thread = state.threadsById[threadId];
-      if (inboxNotification === void 0 || thread === void 0) {
-        return {
-          status: "not-subscribed"
-        };
+      const thread = state.threadsDB.get(threadId);
+      if (notification === void 0 || thread === void 0) {
+        return { status: "not-subscribed" };
       }
       return {
         status: "subscribed",
-        unreadSince: inboxNotification.readAt
+        unreadSince: notification.readAt
       };
     },
     [threadId]
   );
   return useSyncExternalStoreWithSelector2(
-    store.subscribeThreads,
+    store.subscribe,
     store.getFullState,
     store.getFullState,
     selector
@@ -3438,48 +3465,51 @@ function useRoomNotificationSettings() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
   const client = useClient();
   const room = useRoom();
-  const { store } = getRoomExtrasForClient(client);
+  const { store, getOrCreateNotificationsSettingsPollerForRoomId } = getRoomExtrasForClient(client);
+  const poller = getOrCreateNotificationsSettingsPollerForRoomId(room.id);
+  React4.useEffect(
+    () => {
+      void store.waitUntilRoomNotificationSettingsLoaded(room.id);
+    }
+    // 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.
+  );
+  React4.useEffect(() => {
+    poller.inc();
+    poller.pollNowIfStale();
+    return () => {
+      poller.dec();
+    };
+  }, [poller]);
   const getter = React4.useCallback(
-    () => store.getNotificationSettingsAsync(room.id),
+    () => store.getNotificationSettingsLoadingState(room.id),
     [store, room.id]
   );
-  React4.useEffect(() => {
-    const { getInboxNotificationSettings } = getRoomExtrasForClient(client);
-    void getInboxNotificationSettings(room);
-  }, [client, room]);
   const settings = useSyncExternalStoreWithSelector2(
-    store.subscribeNotificationSettings,
+    store.subscribe,
     getter,
     getter,
     identity2,
-    shallow4
+    shallow2
   );
   return React4.useMemo(() => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
 function useRoomNotificationSettingsSuspense() {
-  const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
   const client = useClient();
+  const store = getRoomExtrasForClient(client).store;
   const room = useRoom();
-  const { store } = getRoomExtrasForClient(client);
-  const getter = React4.useCallback(
-    () => store.getNotificationSettingsAsync(room.id),
-    [store, room.id]
-  );
-  const settings = useSyncExternalStoreWithSelector2(
-    store.subscribeNotificationSettings,
-    getter,
-    getter,
-    identity2,
-    shallow4
-  );
-  if (settings.isLoading) {
-    const { getInboxNotificationSettings } = getRoomExtrasForClient(client);
-    throw getInboxNotificationSettings(room);
-  } else if (settings.error) {
-    throw settings.error;
-  }
+  use(store.waitUntilRoomNotificationSettingsLoaded(room.id));
+  const [settings, updateRoomNotificationSettings] = useRoomNotificationSettings();
+  assert2(!settings.error, "Did not expect error");
+  assert2(!settings.isLoading, "Did not expect loading");
   return React4.useMemo(() => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
@@ -3516,45 +3546,48 @@ function useHistoryVersionData(versionId) {
 function useHistoryVersions() {
   const client = useClient();
   const room = useRoom();
-  const { store, getRoomVersions } = getRoomExtrasForClient(client);
+  const { store, getOrCreateVersionsPollerForRoomId } = getRoomExtrasForClient(client);
+  const poller = getOrCreateVersionsPollerForRoomId(room.id);
+  React4.useEffect(() => {
+    poller.inc();
+    poller.pollNowIfStale();
+    return () => poller.dec();
+  }, [poller]);
   const getter = React4.useCallback(
-    () => store.getVersionsAsync(room.id),
+    () => store.getRoomVersionsLoadingState(room.id),
     [store, room.id]
   );
-  React4.useEffect(() => {
-    void getRoomVersions(room);
-  }, [room]);
+  React4.useEffect(
+    () => {
+      void store.waitUntilRoomVersionsLoaded(room.id);
+    }
+    // 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.
+  );
   const state = useSyncExternalStoreWithSelector2(
-    store.subscribeVersions,
+    store.subscribe,
     getter,
     getter,
     identity2,
-    shallow4
+    shallow2
   );
   return state;
 }
 function useHistoryVersionsSuspense() {
   const client = useClient();
   const room = useRoom();
-  const { store } = getRoomExtrasForClient(client);
-  const getter = React4.useCallback(
-    () => store.getVersionsAsync(room.id),
-    [store, room.id]
-  );
-  const state = useSyncExternalStoreWithSelector2(
-    store.subscribeVersions,
-    getter,
-    getter,
-    identity2,
-    shallow4
-  );
-  if (state.isLoading) {
-    const { getRoomVersions } = getRoomExtrasForClient(client);
-    throw getRoomVersions(room);
-  } else if (state.error) {
-    throw state.error;
-  }
-  return state;
+  const store = getRoomExtrasForClient(client).store;
+  use(store.waitUntilRoomVersionsLoaded(room.id));
+  const result = useHistoryVersions();
+  assert2(!result.error, "Did not expect error");
+  assert2(!result.isLoading, "Did not expect loading");
+  return result;
 }
 function useUpdateRoomNotificationSettings() {
   const client = useClient();
@@ -3569,7 +3602,7 @@ function useUpdateRoomNotificationSettings() {
       });
       room.updateNotificationSettings(settings).then(
         (settings2) => {
-          store.updateRoomInboxNotificationSettings2(
+          store.updateRoomNotificationSettings_confirmOptimisticUpdate(
             room.id,
             optimisticUpdateId,
             settings2
@@ -3731,6 +3764,8 @@ var _useOthersMapped = useOthersMapped;
 var _useOthersMappedSuspense = useOthersMappedSuspense;
 var _useThreads = useThreads;
 var _useThreadsSuspense = useThreadsSuspense;
+var _useRoomNotificationSettings = useRoomNotificationSettings;
+var _useRoomNotificationSettingsSuspense = useRoomNotificationSettingsSuspense;
 var _useHistoryVersions = useHistoryVersions;
 var _useHistoryVersionsSuspense = useHistoryVersionsSuspense;
 var _useOther = useOther;
@@ -3754,7 +3789,6 @@ var _useUpdateMyPresence = useUpdateMyPresence;
 
 export {
   RoomContext,
-  selectThreads,
   ClientContext,
   getUmbrellaStoreForClient,
   useClient,
@@ -3796,7 +3830,6 @@ export {
   useMarkThreadAsResolved,
   useMarkThreadAsUnresolved,
   useThreadSubscription,
-  useRoomNotificationSettings,
   useHistoryVersionData,
   useUpdateRoomNotificationSettings,
   useOthersConnectionIdsSuspense,
@@ -3820,6 +3853,8 @@ export {
   _useOthersMappedSuspense,
   _useThreads,
   _useThreadsSuspense,
+  _useRoomNotificationSettings,
+  _useRoomNotificationSettingsSuspense,
   _useHistoryVersions,
   _useHistoryVersionsSuspense,
   _useOther,
@@ -3833,4 +3868,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-LMENFXCS.mjs.map
+//# sourceMappingURL=chunk-A7GJNN4L.mjs.map