@liveblocks/react 2.15.1 → 2.15.2

package/dist/{chunk-GMKB6I6V.mjs → chunk-EEYUKRIA.mjs}

@@ -85,6 +85,18 @@ function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnaps
   return value;
 }
 
+// src/use-signal.ts
+var identity = (value) => value;
+function useSignal(signal, selector, isEqual) {
+  return useSyncExternalStoreWithSelector(
+    signal.subscribe,
+    signal.get,
+    signal.get,
+    selector ?? identity,
+    isEqual
+  );
+}
+
 // src/liveblocks.tsx
 import {
   assert,
@@ -121,19 +133,30 @@ var config = {
   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);
+// src/lib/AsyncResult.ts
+var ASYNC_LOADING = Object.freeze({ isLoading: true });
+var ASYNC_ERR = (error) => Object.freeze({ isLoading: false, error });
+function ASYNC_OK(fieldOrData, data) {
+  if (arguments.length === 1) {
+    return Object.freeze({ isLoading: false, data: fieldOrData });
+  } else {
+    return Object.freeze({ isLoading: false, [fieldOrData]: data });
   }
-  const keysA = Object.keys(a);
-  if (keysA.length !== Object.keys(b).length) {
-    return false;
+}
+
+// src/lib/itertools.ts
+function find(it, predicate) {
+  for (const item of it) {
+    if (predicate(item)) return item;
   }
-  return keysA.every(
-    (key) => Object.prototype.hasOwnProperty.call(b, key) && shallow(a[key], b[key])
-  );
+  return void 0;
+}
+function count(it, predicate) {
+  let total = 0;
+  for (const item of it) {
+    if (predicate(item)) total++;
+  }
+  return total;
 }
 
 // src/lib/use-initial.ts
@@ -199,16 +222,17 @@ import {
   batch as batch2,
   compactObject,
   console as console2,
+  DefaultMap,
   DerivedSignal,
   HttpError,
   kInternal,
-  makeEventSource,
   MutableSignal as MutableSignal2,
   nanoid,
   nn,
   shallow as shallow3,
   Signal,
-  stringify
+  stringify,
+  unstringify
 } from "@liveblocks/core";
 
 // src/lib/autobind.ts
@@ -228,12 +252,19 @@ function autobind(self) {
   } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
 }
 
-// src/lib/itertools.ts
-function find(it, predicate) {
-  for (const item of it) {
-    if (predicate(item)) return item;
+// src/lib/shallow2.ts
+import { isPlainObject, shallow } from "@liveblocks/core";
+function shallow2(a, b) {
+  if (!isPlainObject(a) || !isPlainObject(b)) {
+    return shallow(a, b);
   }
-  return void 0;
+  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/ThreadDB.ts
@@ -355,12 +386,12 @@ var ThreadDB = class _ThreadDB {
       this.upsert(thread);
     }
   }
-  applyDelta(updates) {
+  applyDelta(newThreads, deletedThreads) {
     batch(() => {
-      for (const thread of updates.newThreads) {
+      for (const thread of newThreads) {
         this.upsertIfNewer(thread);
       }
-      for (const { id, deletedAt } of updates.deletedThreads) {
+      for (const { id, deletedAt } of deletedThreads) {
         const existing = this.getEvenIfDeleted(id);
         if (!existing) continue;
         this.delete(id, deletedAt);
@@ -401,16 +432,10 @@ var ThreadDB = class _ThreadDB {
 
 // src/umbrella-store.ts
 function makeRoomThreadsQueryKey(roomId, query) {
-  return `${roomId}-${stringify(query ?? {})}`;
+  return stringify([roomId, query ?? {}]);
 }
 function makeUserThreadsQueryKey(query) {
-  return `USER_THREADS:${stringify(query ?? {})}`;
-}
-function makeNotificationSettingsQueryKey(roomId) {
-  return `${roomId}:NOTIFICATION_SETTINGS`;
-}
-function makeVersionsQueryKey(roomId) {
-  return `${roomId}-VERSIONS`;
+  return stringify(query ?? {});
 }
 function usify(promise) {
   if ("status" in promise) {
@@ -431,53 +456,50 @@ function usify(promise) {
   return usable;
 }
 var noop2 = Promise.resolve();
-var ASYNC_LOADING = Object.freeze({ isLoading: true });
 var PaginatedResource = class {
-  observable;
-  #eventSource;
+  #signal;
+  signal;
   #fetchPage;
-  #paginationState;
-  // Should be null while in loading or error state!
   #pendingFetchMore;
   constructor(fetchPage) {
-    this.#paginationState = null;
+    this.#signal = new Signal(ASYNC_LOADING);
     this.#fetchPage = fetchPage;
-    this.#eventSource = makeEventSource();
     this.#pendingFetchMore = null;
-    this.observable = this.#eventSource.observable;
+    this.signal = this.#signal.asReadonly();
     autobind(this);
   }
-  #patchPaginationState(patch) {
-    const state = this.#paginationState;
-    if (state === null) return;
-    this.#paginationState = { ...state, ...patch };
-    this.#eventSource.notify();
+  get() {
+    return this.#signal.get();
+  }
+  #patch(patch) {
+    const state = this.#signal.get();
+    if (state.data === void 0) return;
+    this.#signal.set(ASYNC_OK({ ...state.data, ...patch }));
   }
   async #fetchMore() {
-    const state = this.#paginationState;
-    if (!state?.cursor) {
+    const state = this.#signal.get();
+    if (!state.data?.cursor || state.data.isFetchingMore) {
       return;
     }
-    this.#patchPaginationState({ isFetchingMore: true });
+    this.#patch({ isFetchingMore: true });
     try {
-      const nextCursor = await this.#fetchPage(state.cursor);
-      this.#patchPaginationState({
+      const nextCursor = await this.#fetchPage(state.data.cursor);
+      this.#patch({
         cursor: nextCursor,
+        hasFetchedAll: nextCursor === null,
         fetchMoreError: void 0,
         isFetchingMore: false
       });
     } catch (err) {
-      this.#patchPaginationState({
+      this.#patch({
         isFetchingMore: false,
         fetchMoreError: err
       });
     }
   }
   fetchMore() {
-    const state = this.#paginationState;
-    if (state?.cursor === null) {
-      return noop2;
-    }
+    const state = this.#signal.get();
+    if (!state.data?.cursor) return noop2;
     if (!this.#pendingFetchMore) {
       this.#pendingFetchMore = this.#fetchMore().finally(() => {
         this.#pendingFetchMore = null;
@@ -485,31 +507,12 @@ var PaginatedResource = class {
     }
     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
-      }
-    };
-  }
   #cachedPromise = null;
   waitUntilLoaded() {
     if (this.#cachedPromise) {
       return this.#cachedPromise;
     }
-    const initialFetcher = autoRetry(
+    const initialPageFetch$ = autoRetry(
       () => this.#fetchPage(
         /* cursor */
         void 0
@@ -517,67 +520,64 @@ var PaginatedResource = class {
       5,
       [5e3, 5e3, 1e4, 15e3]
     );
-    const promise = usify(
-      initialFetcher.then((cursor) => {
-        this.#paginationState = {
-          cursor,
-          isFetchingMore: false,
-          fetchMoreError: void 0
-        };
-      })
-    );
+    const promise = usify(initialPageFetch$);
     promise.then(
-      () => this.#eventSource.notify(),
-      () => {
-        this.#eventSource.notify();
+      (cursor) => {
+        this.#signal.set(
+          ASYNC_OK({
+            cursor,
+            hasFetchedAll: cursor === null,
+            isFetchingMore: false,
+            fetchMoreError: void 0,
+            fetchMore: this.fetchMore
+          })
+        );
+      },
+      (err) => {
+        this.#signal.set(ASYNC_ERR(err));
         setTimeout(() => {
           this.#cachedPromise = null;
-          this.#eventSource.notify();
+          this.#signal.set(ASYNC_LOADING);
         }, 5e3);
       }
     );
     this.#cachedPromise = promise;
-    return promise;
+    return this.#cachedPromise;
   }
 };
 var SinglePageResource = class {
-  observable;
-  #eventSource;
+  #signal;
+  signal;
   #fetchPage;
   constructor(fetchPage) {
+    this.#signal = new Signal(ASYNC_LOADING);
+    this.signal = this.#signal.asReadonly();
     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;
-    } else if (usable.status === "rejected") {
-      return { isLoading: false, error: usable.reason };
-    } else {
-      return { isLoading: false, data: void 0 };
-    }
+    return this.#signal.get();
   }
   #cachedPromise = null;
   waitUntilLoaded() {
     if (this.#cachedPromise) {
       return this.#cachedPromise;
     }
-    const initialFetcher = autoRetry(
+    const initialFetcher$ = autoRetry(
       () => this.#fetchPage(),
       5,
       [5e3, 5e3, 1e4, 15e3]
     );
-    const promise = usify(initialFetcher);
+    const promise = usify(initialFetcher$);
     promise.then(
-      () => this.#eventSource.notify(),
       () => {
-        this.#eventSource.notify();
+        this.#signal.set(ASYNC_OK(void 0));
+      },
+      (err) => {
+        this.#signal.set(ASYNC_ERR(err));
         setTimeout(() => {
           this.#cachedPromise = null;
-          this.#eventSource.notify();
+          this.#signal.set(ASYNC_LOADING);
         }, 5e3);
       }
     );
@@ -610,10 +610,10 @@ function createStore_forNotifications() {
   function clear() {
     signal.mutate((lut) => lut.clear());
   }
-  function applyDelta(newInboxNotifications, deletedNotifications) {
+  function applyDelta(newNotifications, deletedNotifications) {
     signal.mutate((lut) => {
       let mutated = false;
-      for (const n of newInboxNotifications) {
+      for (const n of newNotifications) {
         const existing = lut.get(n.id);
         if (existing) {
           const result = compareInboxNotifications(existing, n);
@@ -644,6 +644,11 @@ function createStore_forNotifications() {
       return true;
     });
   }
+  function upsert(notification) {
+    signal.mutate((lut) => {
+      lut.set(notification.id, notification);
+    });
+  }
   return {
     signal: signal.asReadonly(),
     // Mutations
@@ -653,66 +658,70 @@ function createStore_forNotifications() {
     applyDelta,
     clear,
     updateAssociatedNotification,
-    // XXX_vincent Remove this eventually
-    force_set: (mutationCallback) => signal.mutate(mutationCallback),
-    invalidate: () => signal.mutate()
+    upsert
   };
 }
-function createStore_forRoomNotificationSettings() {
-  const signal = new MutableSignal2(/* @__PURE__ */ new Map());
+function createStore_forRoomNotificationSettings(updates) {
+  const baseSignal = new MutableSignal2(/* @__PURE__ */ new Map());
   function update(roomId, settings) {
-    signal.mutate((lut) => {
+    baseSignal.mutate((lut) => {
       lut.set(roomId, settings);
     });
   }
   return {
-    signal: signal.asReadonly(),
+    signal: DerivedSignal.from(
+      baseSignal,
+      updates,
+      (base, updates2) => applyOptimisticUpdates_forSettings(base, updates2)
+    ),
     // Mutations
-    update,
-    // XXX_vincent Remove this eventually
-    invalidate: () => signal.mutate()
+    update
   };
 }
 function createStore_forHistoryVersions() {
-  const signal = new MutableSignal2(/* @__PURE__ */ new Map());
+  const baseSignal = new MutableSignal2(
+    new DefaultMap(() => /* @__PURE__ */ new Map())
+  );
   function update(roomId, versions) {
-    signal.mutate((lut) => {
-      const versionsById = lut.get(roomId) ?? (lut.set(roomId, /* @__PURE__ */ new Map()), lut.get(roomId));
+    baseSignal.mutate((lut) => {
+      const versionsById = lut.getOrCreate(roomId);
       for (const version of versions) {
         versionsById.set(version.id, version);
       }
     });
   }
   return {
-    signal: signal.asReadonly(),
+    signal: DerivedSignal.from(
+      baseSignal,
+      (hv) => Object.fromEntries(
+        [...hv].map(([roomId, versions]) => [
+          roomId,
+          Object.fromEntries(versions)
+        ])
+      )
+    ),
     // Mutations
-    update,
-    // XXX_vincent Remove these eventually
-    force_set: (callback) => signal.mutate(callback),
-    invalidate: () => signal.mutate()
+    update
   };
 }
 function createStore_forPermissionHints() {
-  const signal = new Signal({});
+  const signal = new MutableSignal2(
+    new DefaultMap(() => /* @__PURE__ */ new Set())
+  );
   function update(newHints) {
-    signal.set((prev) => {
-      const permissionsByRoom = { ...prev };
+    signal.mutate((lut) => {
       for (const [roomId, newPermissions] of Object.entries(newHints)) {
-        const existing = permissionsByRoom[roomId] ?? /* @__PURE__ */ new Set();
+        const existing = lut.getOrCreate(roomId);
         for (const permission of newPermissions) {
           existing.add(permission);
         }
-        permissionsByRoom[roomId] = existing;
       }
-      return permissionsByRoom;
     });
   }
   return {
     signal: signal.asReadonly(),
     // Mutations
-    update,
-    // XXX_vincent Remove this eventually
-    invalidate: () => signal.set((store) => ({ ...store }))
+    update
   };
 }
 function createStore_forOptimistic(client) {
@@ -736,9 +745,7 @@ function createStore_forOptimistic(client) {
     signal: signal.asReadonly(),
     // Mutations
     add,
-    remove,
-    // XXX_vincent Remove this eventually
-    invalidate: () => signal.set((store) => [...store])
+    remove
   };
 }
 var UmbrellaStore = class {
@@ -788,48 +795,37 @@ var UmbrellaStore = class {
   // threads and notifications separately, but the threadifications signal will
   // be updated whenever either of them change.
   //
-  // XXX_vincent APIs like getRoomThreadsLoadingState should really also be modeled as output signals.
-  //
   outputs;
   // Notifications
   #notificationsLastRequestedAt = null;
   // Keeps track of when we successfully requested an inbox notifications update for the last time. Will be `null` as long as the first successful fetch hasn't happened yet.
-  #notifications;
+  #notificationsPaginationState;
   // Room Threads
   #roomThreadsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
-  #roomThreads = /* @__PURE__ */ new Map();
   // User Threads
   #userThreadsLastRequestedAt = null;
-  #userThreads = /* @__PURE__ */ new Map();
   // Room versions
-  #roomVersions = /* @__PURE__ */ new Map();
   #roomVersionsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
-  // Room notification settings
-  #roomNotificationSettings = /* @__PURE__ */ new Map();
   constructor(client) {
     this.#client = client[kInternal].as();
     this.optimisticUpdates = createStore_forOptimistic(this.#client);
     this.permissionHints = createStore_forPermissionHints();
-    const inboxFetcher = async (cursor) => {
-      const result = await this.#client.getInboxNotifications({ cursor });
-      this.updateThreadifications(result.threads, result.inboxNotifications);
-      if (this.#notificationsLastRequestedAt === null) {
-        this.#notificationsLastRequestedAt = result.requestedAt;
+    this.#notificationsPaginationState = new PaginatedResource(
+      async (cursor) => {
+        const result = await this.#client.getInboxNotifications({ cursor });
+        this.updateThreadifications(result.threads, result.inboxNotifications);
+        if (this.#notificationsLastRequestedAt === null) {
+          this.#notificationsLastRequestedAt = result.requestedAt;
+        }
+        const nextCursor = result.nextCursor;
+        return nextCursor;
       }
-      const nextCursor = result.nextCursor;
-      return nextCursor;
-    };
-    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.invalidateEntireStore()
-      )
     );
     this.threads = new ThreadDB();
     this.notifications = createStore_forNotifications();
-    this.roomNotificationSettings = createStore_forRoomNotificationSettings();
+    this.roomNotificationSettings = createStore_forRoomNotificationSettings(
+      this.optimisticUpdates.signal
+    );
     this.historyVersions = createStore_forHistoryVersions();
     const threadifications = DerivedSignal.from(
       this.threads.signal,
@@ -837,13 +833,7 @@ var UmbrellaStore = class {
       this.optimisticUpdates.signal,
       (ts, ns, updates) => applyOptimisticUpdates_forThreadifications(ts, ns, updates)
     );
-    const threads = DerivedSignal.from(
-      threadifications,
-      (s) => ({
-        threadsDB: s.threadsDB
-      }),
-      shallow3
-    );
+    const threads = DerivedSignal.from(threadifications, (s) => s.threadsDB);
     const notifications = DerivedSignal.from(
       threadifications,
       (s) => ({
@@ -852,177 +842,181 @@ var UmbrellaStore = class {
       }),
       shallow3
     );
-    const settingsByRoomId = DerivedSignal.from(
-      this.roomNotificationSettings.signal,
-      this.optimisticUpdates.signal,
-      (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
+    const loadingUserThreads = new DefaultMap(
+      (queryKey) => {
+        const query = unstringify(queryKey);
+        const resource = new PaginatedResource(async (cursor) => {
+          const result = await this.#client[kInternal].httpClient.getUserThreads_experimental({
+            cursor,
+            query
+          });
+          this.updateThreadifications(
+            result.threads,
+            result.inboxNotifications
+          );
+          this.permissionHints.update(result.permissionHints);
+          if (this.#userThreadsLastRequestedAt === null) {
+            this.#userThreadsLastRequestedAt = result.requestedAt;
+          }
+          return result.nextCursor;
+        });
+        const signal = DerivedSignal.from(() => {
+          const result = resource.get();
+          if (result.isLoading || result.error) {
+            return result;
+          }
+          const threads2 = this.outputs.threads.get().findMany(
+            void 0,
+            // Do _not_ filter by roomId
+            query ?? {},
+            "desc"
+          );
+          const page = result.data;
+          return {
+            isLoading: false,
+            threads: threads2,
+            hasFetchedAll: page.hasFetchedAll,
+            isFetchingMore: page.isFetchingMore,
+            fetchMoreError: page.fetchMoreError,
+            fetchMore: page.fetchMore
+          };
+        }, shallow2);
+        return { signal, waitUntilLoaded: resource.waitUntilLoaded };
+      }
     );
-    const versionsByRoomId = DerivedSignal.from(
-      this.historyVersions.signal,
-      (hv) => Object.fromEntries(
-        [...hv].map(([roomId, versions]) => [
-          roomId,
-          Object.fromEntries(versions)
-        ])
-      )
+    const loadingRoomThreads = new DefaultMap(
+      (queryKey) => {
+        const [roomId, query] = unstringify(queryKey);
+        const resource = new PaginatedResource(async (cursor) => {
+          const result = await this.#client[kInternal].httpClient.getThreads({
+            roomId,
+            cursor,
+            query
+          });
+          this.updateThreadifications(
+            result.threads,
+            result.inboxNotifications
+          );
+          this.permissionHints.update(result.permissionHints);
+          const lastRequestedAt = this.#roomThreadsLastRequestedAtByRoom.get(roomId);
+          if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
+            this.#roomThreadsLastRequestedAtByRoom.set(
+              roomId,
+              result.requestedAt
+            );
+          }
+          return result.nextCursor;
+        });
+        const signal = DerivedSignal.from(() => {
+          const result = resource.get();
+          if (result.isLoading || result.error) {
+            return result;
+          }
+          const threads2 = this.outputs.threads.get().findMany(roomId, query ?? {}, "asc");
+          const page = result.data;
+          return {
+            isLoading: false,
+            threads: threads2,
+            hasFetchedAll: page.hasFetchedAll,
+            isFetchingMore: page.isFetchingMore,
+            fetchMoreError: page.fetchMoreError,
+            fetchMore: page.fetchMore
+          };
+        }, shallow2);
+        return { signal, waitUntilLoaded: resource.waitUntilLoaded };
+      }
+    );
+    const loadingNotifications = {
+      signal: DerivedSignal.from(() => {
+        const result = this.#notificationsPaginationState.get();
+        if (result.isLoading || result.error) {
+          return result;
+        }
+        const page = result.data;
+        return {
+          isLoading: false,
+          inboxNotifications: this.outputs.notifications.get().sortedNotifications,
+          hasFetchedAll: page.hasFetchedAll,
+          isFetchingMore: page.isFetchingMore,
+          fetchMoreError: page.fetchMoreError,
+          fetchMore: page.fetchMore
+        };
+      }),
+      waitUntilLoaded: this.#notificationsPaginationState.waitUntilLoaded
+    };
+    const settingsByRoomId = new DefaultMap((roomId) => {
+      const resource = new SinglePageResource(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.roomNotificationSettings.update(roomId, result);
+      });
+      const signal = DerivedSignal.from(() => {
+        const result = resource.get();
+        if (result.isLoading || result.error) {
+          return result;
+        } else {
+          return ASYNC_OK(
+            "settings",
+            nn(this.roomNotificationSettings.signal.get()[roomId])
+          );
+        }
+      }, shallow3);
+      return { signal, waitUntilLoaded: resource.waitUntilLoaded };
+    });
+    const versionsByRoomId = new DefaultMap(
+      (roomId) => {
+        const resource = new SinglePageResource(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.historyVersions.update(roomId, result.versions);
+          const lastRequestedAt = this.#roomVersionsLastRequestedAtByRoom.get(roomId);
+          if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
+            this.#roomVersionsLastRequestedAtByRoom.set(
+              roomId,
+              result.requestedAt
+            );
+          }
+        });
+        const signal = DerivedSignal.from(() => {
+          const result = resource.get();
+          if (result.isLoading || result.error) {
+            return result;
+          } else {
+            return {
+              isLoading: false,
+              versions: Object.values(
+                this.historyVersions.signal.get()[roomId] ?? {}
+              )
+            };
+          }
+        }, shallow3);
+        return { signal, waitUntilLoaded: resource.waitUntilLoaded };
+      }
     );
     this.outputs = {
       threadifications,
       threads,
+      loadingRoomThreads,
+      loadingUserThreads,
       notifications,
+      loadingNotifications,
       settingsByRoomId,
       versionsByRoomId
     };
     autobind(this);
   }
-  get1_both() {
-    return this.outputs.threadifications.get();
-  }
-  subscribe1_both(callback) {
-    return this.outputs.threadifications.subscribe(callback);
-  }
-  get1_threads() {
-    return this.outputs.threads.get();
-  }
-  subscribe1_threads(callback) {
-    return this.outputs.threads.subscribe(callback);
-  }
-  get1_notifications() {
-    return this.outputs.notifications.get();
-  }
-  subscribe1_notifications(callback) {
-    return this.outputs.notifications.subscribe(callback);
-  }
-  get2() {
-    return this.outputs.settingsByRoomId.get();
-  }
-  subscribe2(callback) {
-    return this.outputs.settingsByRoomId.subscribe(callback);
-  }
-  get3() {
-    return this.outputs.versionsByRoomId.get();
-  }
-  subscribe3(callback) {
-    return this.outputs.versionsByRoomId.subscribe(callback);
-  }
-  /**
-   * 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.
-   *
-   */
-  getRoomThreadsLoadingState(roomId, query) {
-    const queryKey = makeRoomThreadsQueryKey(roomId, query);
-    const paginatedResource = this.#roomThreads.get(queryKey);
-    if (paginatedResource === void 0) {
-      return ASYNC_LOADING;
-    }
-    const asyncResult = paginatedResource.get();
-    if (asyncResult.isLoading || asyncResult.error) {
-      return asyncResult;
-    }
-    const threads = this.get1_threads().threadsDB.findMany(
-      roomId,
-      query ?? {},
-      "asc"
-    );
-    const page = asyncResult.data;
-    return {
-      isLoading: false,
-      threads,
-      hasFetchedAll: page.hasFetchedAll,
-      isFetchingMore: page.isFetchingMore,
-      fetchMoreError: page.fetchMoreError,
-      fetchMore: page.fetchMore
-    };
-  }
-  getUserThreadsLoadingState(query) {
-    const queryKey = makeUserThreadsQueryKey(query);
-    const paginatedResource = this.#userThreads.get(queryKey);
-    if (paginatedResource === void 0) {
-      return ASYNC_LOADING;
-    }
-    const asyncResult = paginatedResource.get();
-    if (asyncResult.isLoading || asyncResult.error) {
-      return asyncResult;
-    }
-    const threads = this.get1_threads().threadsDB.findMany(
-      void 0,
-      // Do _not_ filter by roomId
-      query ?? {},
-      "desc"
-    );
-    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!
-  getInboxNotificationsLoadingState() {
-    const asyncResult = this.#notifications.get();
-    if (asyncResult.isLoading || asyncResult.error) {
-      return asyncResult;
-    }
-    const page = asyncResult.data;
-    return {
-      isLoading: false,
-      inboxNotifications: this.get1_notifications().sortedNotifications,
-      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!
-  // XXX_vincent This should really be a derived Signal!
-  getNotificationSettingsLoadingState(roomId) {
-    const queryKey = makeNotificationSettingsQueryKey(roomId);
-    const resource = this.#roomNotificationSettings.get(queryKey);
-    if (resource === void 0) {
-      return ASYNC_LOADING;
-    }
-    const asyncResult = resource.get();
-    if (asyncResult.isLoading || asyncResult.error) {
-      return asyncResult;
-    }
-    return {
-      isLoading: false,
-      settings: nn(this.get2()[roomId])
-    };
-  }
-  getRoomVersionsLoadingState(roomId) {
-    const queryKey = makeVersionsQueryKey(roomId);
-    const resource = this.#roomVersions.get(queryKey);
-    if (resource === void 0) {
-      return ASYNC_LOADING;
-    }
-    const asyncResult = resource.get();
-    if (asyncResult.isLoading || asyncResult.error) {
-      return asyncResult;
-    }
-    return {
-      isLoading: false,
-      versions: Object.values(this.get3()[roomId] ?? {})
-    };
-  }
-  /** @internal - Only call this method from unit tests. */
-  force_set_versions(callback) {
-    batch2(() => {
-      this.historyVersions.force_set(callback);
-      this.invalidateEntireStore();
-    });
-  }
-  /** @internal - Only call this method from unit tests. */
-  force_set_notifications(callback) {
-    batch2(() => {
-      this.notifications.force_set(callback);
-      this.invalidateEntireStore();
-    });
-  }
   /**
    * Updates an existing inbox notification with a new value, replacing the
    * corresponding optimistic update.
@@ -1164,7 +1158,7 @@ var UmbrellaStore = class {
   }
   updateThreadifications(threads, notifications, deletedThreads = [], deletedNotifications = []) {
     batch2(() => {
-      this.threads.applyDelta({ newThreads: threads, deletedThreads });
+      this.threads.applyDelta(threads, deletedThreads);
       this.notifications.applyDelta(notifications, deletedNotifications);
     });
   }
@@ -1197,39 +1191,6 @@ var UmbrellaStore = class {
       result.inboxNotifications.deleted
     );
   }
-  waitUntilNotificationsLoaded() {
-    return this.#notifications.waitUntilLoaded();
-  }
-  waitUntilRoomThreadsLoaded(roomId, query) {
-    const threadsFetcher = async (cursor) => {
-      const result = await this.#client[kInternal].httpClient.getThreads({
-        roomId,
-        cursor,
-        query
-      });
-      this.updateThreadifications(result.threads, result.inboxNotifications);
-      this.permissionHints.update(result.permissionHints);
-      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.invalidateEntireStore()
-      )
-    );
-    this.#roomThreads.set(queryKey, paginatedResource);
-    return paginatedResource.waitUntilLoaded();
-  }
   async fetchRoomThreadsDeltaUpdate(roomId, signal) {
     const lastRequestedAt = this.#roomThreadsLastRequestedAtByRoom.get(roomId);
     if (lastRequestedAt === void 0) {
@@ -1251,45 +1212,6 @@ var UmbrellaStore = class {
       this.#roomThreadsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
     }
   }
-  waitUntilUserThreadsLoaded(query) {
-    const queryKey = makeUserThreadsQueryKey(query);
-    const threadsFetcher = async (cursor) => {
-      const result = await this.#client[kInternal].httpClient.getUserThreads_experimental({
-        cursor,
-        query
-      });
-      this.updateThreadifications(result.threads, result.inboxNotifications);
-      this.permissionHints.update(result.permissionHints);
-      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.invalidateEntireStore()
-      )
-    );
-    this.#userThreads.set(queryKey, paginatedResource);
-    return paginatedResource.waitUntilLoaded();
-  }
-  // XXX_vincent We should really be going over all call sites, and replace this call
-  // with a more specific invalidation!
-  invalidateEntireStore() {
-    batch2(() => {
-      this.historyVersions.invalidate();
-      this.notifications.invalidate();
-      this.optimisticUpdates.invalidate();
-      this.permissionHints.invalidate();
-      this.roomNotificationSettings.invalidate();
-    });
-  }
   async fetchUserThreadsDeltaUpdate(signal) {
     const lastRequestedAt = this.#userThreadsLastRequestedAt;
     if (lastRequestedAt === null) {
@@ -1310,40 +1232,6 @@ var UmbrellaStore = class {
     );
     this.permissionHints.update(result.permissionHints);
   }
-  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.historyVersions.update(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.invalidateEntireStore()
-      )
-    );
-    this.#roomVersions.set(queryKey, resource);
-    return resource.waitUntilLoaded();
-  }
   async fetchRoomVersionsDeltaUpdate(roomId, signal) {
     const lastRequestedAt = this.#roomVersionsLastRequestedAtByRoom.get(roomId);
     if (lastRequestedAt === void 0) {
@@ -1362,33 +1250,6 @@ var UmbrellaStore = class {
       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.roomNotificationSettings.update(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.invalidateEntireStore()
-      )
-    );
-    this.#roomNotificationSettings.set(queryKey, resource);
-    return resource.waitUntilLoaded();
-  }
   async refreshRoomNotificationSettings(roomId, signal) {
     const room = nn(
       this.#client.getRoom(roomId),
@@ -1760,29 +1621,23 @@ function missingRoomInfoError(roomId) {
     `resolveRoomsInfo didn't return anything for room '${roomId}'`
   );
 }
-function identity(x) {
+function identity2(x) {
   return x;
 }
 var _umbrellaStores = /* @__PURE__ */ new WeakMap();
 var _extras = /* @__PURE__ */ new WeakMap();
 var _bundles = /* @__PURE__ */ new WeakMap();
-function selectUnreadInboxNotificationsCount(inboxNotifications) {
-  let count = 0;
-  for (const notification of inboxNotifications) {
-    if (notification.readAt === null || notification.readAt < notification.notifiedAt) {
-      count++;
-    }
-  }
-  return count;
-}
 function selectorFor_useUnreadInboxNotificationsCount(result) {
   if (!result.inboxNotifications) {
     return result;
   }
-  return {
-    isLoading: false,
-    count: selectUnreadInboxNotificationsCount(result.inboxNotifications)
-  };
+  return ASYNC_OK(
+    "count",
+    count(
+      result.inboxNotifications,
+      (n) => n.readAt === null || n.readAt < n.notifiedAt
+    )
+  );
 }
 function selectorFor_useUser(state, userId) {
   if (state === void 0 || state?.isLoading) {
@@ -1889,7 +1744,7 @@ function makeLiveblocksContextBundle(client) {
   const shared = createSharedContext(client);
   const bundle = {
     LiveblocksProvider: LiveblocksProvider2,
-    useInboxNotifications: () => useInboxNotifications_withClient(client, identity, shallow4),
+    useInboxNotifications: () => useInboxNotifications_withClient(client, identity2, shallow4),
     useUnreadInboxNotificationsCount: () => useUnreadInboxNotificationsCount_withClient(client),
     useMarkInboxNotificationAsRead: useMarkInboxNotificationAsRead2,
     useMarkAllInboxNotificationsAsRead: useMarkAllInboxNotificationsAsRead2,
@@ -1915,9 +1770,17 @@ function makeLiveblocksContextBundle(client) {
 }
 function useInboxNotifications_withClient(client, selector, isEqual) {
   const { store, notificationsPoller: poller } = getLiveblocksExtrasForClient(client);
-  useEffect3(() => {
-    void store.waitUntilNotificationsLoaded();
-  });
+  useEffect3(
+    () => void store.outputs.loadingNotifications.waitUntilLoaded()
+    // 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(() => {
     poller.inc();
     poller.pollNowIfStale();
@@ -1925,18 +1788,16 @@ function useInboxNotifications_withClient(client, selector, isEqual) {
       poller.dec();
     };
   }, [poller]);
-  return useSyncExternalStoreWithSelector(
-    store.subscribe1_notifications,
-    store.getInboxNotificationsLoadingState,
-    store.getInboxNotificationsLoadingState,
+  return useSignal(
+    store.outputs.loadingNotifications.signal,
     selector,
     isEqual
   );
 }
 function useInboxNotificationsSuspense_withClient(client) {
   const store = getLiveblocksExtrasForClient(client).store;
-  use(store.waitUntilNotificationsLoaded());
-  const result = useInboxNotifications_withClient(client, identity, shallow4);
+  use(store.outputs.loadingNotifications.waitUntilLoaded());
+  const result = useInboxNotifications_withClient(client, identity2, shallow4);
   assert(!result.error, "Did not expect error");
   assert(!result.isLoading, "Did not expect loading");
   return result;
@@ -1950,7 +1811,7 @@ function useUnreadInboxNotificationsCount_withClient(client) {
 }
 function useUnreadInboxNotificationsCountSuspense_withClient(client) {
   const store = getLiveblocksExtrasForClient(client).store;
-  use(store.waitUntilNotificationsLoaded());
+  use(store.outputs.loadingNotifications.waitUntilLoaded());
   const result = useUnreadInboxNotificationsCount_withClient(client);
   assert(!result.isLoading, "Did not expect loading");
   assert(!result.error, "Did not expect error");
@@ -2042,34 +1903,31 @@ function useDeleteAllInboxNotifications_withClient(client) {
 }
 function useInboxNotificationThread_withClient(client, inboxNotificationId) {
   const { store } = getLiveblocksExtrasForClient(client);
-  const getter = store.get1_both;
-  const selector = useCallback2(
-    (state) => {
-      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"`
+  return useSignal(
+    store.outputs.threadifications,
+    useCallback2(
+      (state) => {
+        const inboxNotification = state.notificationsById[inboxNotificationId] ?? raise(
+          `Inbox notification with ID "${inboxNotificationId}" not found`
         );
-      }
-      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;
-    },
-    [inboxNotificationId]
-  );
-  return useSyncExternalStoreWithSelector(
-    store.subscribe1_both,
-    // Re-evaluate if we need to update any time the notification changes over time
-    getter,
-    getter,
-    selector
+        if (inboxNotification.kind !== "thread") {
+          raise(
+            `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
+          );
+        }
+        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;
+      },
+      [inboxNotificationId]
+    )
   );
 }
 function useUser_withClient(client, userId) {
   const usersStore = client[kInternal2].usersStore;
   const getUserState = useCallback2(
-    () => usersStore.getState(userId),
+    () => usersStore.getItemState(userId),
     [usersStore, userId]
   );
   const selector = useCallback2(
@@ -2083,20 +1941,29 @@ function useUser_withClient(client, userId) {
     selector,
     shallow4
   );
-  useEffect3(() => {
-    void usersStore.get(userId);
-  }, [usersStore, userId, result]);
+  useEffect3(
+    () => void usersStore.enqueue(userId)
+    // NOTE: Deliberately *not* using a dependency array here!
+    //
+    // It is important to call usersStore.enqueue on *every* render.
+    // This is harmless though, on most renders, except:
+    // 1. The very first render, in which case we'll want to trigger evaluation
+    //    of the userId.
+    // 2. All other subsequent renders now are a no-op (from the implementation
+    //    of .enqueue)
+    // 3. If ever the userId gets invalidated, the user would be fetched again.
+  );
   return result;
 }
 function useUserSuspense_withClient(client, userId) {
   const usersStore = client[kInternal2].usersStore;
   const getUserState = useCallback2(
-    () => usersStore.getState(userId),
+    () => usersStore.getItemState(userId),
     [usersStore, userId]
   );
   const userState = getUserState();
   if (!userState || userState.isLoading) {
-    throw usersStore.get(userId);
+    throw usersStore.enqueue(userId);
   }
   if (userState.error) {
     throw userState.error;
@@ -2121,7 +1988,7 @@ function useUserSuspense_withClient(client, userId) {
 function useRoomInfo_withClient(client, roomId) {
   const roomsInfoStore = client[kInternal2].roomsInfoStore;
   const getRoomInfoState = useCallback2(
-    () => roomsInfoStore.getState(roomId),
+    () => roomsInfoStore.getItemState(roomId),
     [roomsInfoStore, roomId]
   );
   const selector = useCallback2(
@@ -2135,20 +2002,29 @@ function useRoomInfo_withClient(client, roomId) {
     selector,
     shallow4
   );
-  useEffect3(() => {
-    void roomsInfoStore.get(roomId);
-  }, [roomsInfoStore, roomId, result]);
+  useEffect3(
+    () => void roomsInfoStore.enqueue(roomId)
+    // NOTE: Deliberately *not* using a dependency array here!
+    //
+    // It is important to call roomsInfoStore.enqueue on *every* render.
+    // This is harmless though, on most renders, except:
+    // 1. The very first render, in which case we'll want to trigger evaluation
+    //    of the roomId.
+    // 2. All other subsequent renders now are a no-op (from the implementation
+    //    of .enqueue)
+    // 3. If ever the roomId gets invalidated, the room info would be fetched again.
+  );
   return result;
 }
 function useRoomInfoSuspense_withClient(client, roomId) {
   const roomsInfoStore = client[kInternal2].roomsInfoStore;
   const getRoomInfoState = useCallback2(
-    () => roomsInfoStore.getState(roomId),
+    () => roomsInfoStore.getItemState(roomId),
     [roomsInfoStore, roomId]
   );
   const roomInfoState = getRoomInfoState();
   if (!roomInfoState || roomInfoState.isLoading) {
-    throw roomsInfoStore.get(roomId);
+    throw roomsInfoStore.enqueue(roomId);
   }
   if (roomInfoState.error) {
     throw roomInfoState.error;
@@ -2250,10 +2126,9 @@ function useUserThreads_experimental(options = {
 }) {
   const client = useClient();
   const { store, userThreadsPoller: poller } = getLiveblocksExtrasForClient(client);
+  const queryKey = makeUserThreadsQueryKey(options.query);
   useEffect3(
-    () => {
-      void store.waitUntilUserThreadsLoaded(options.query);
-    }
+    () => void store.outputs.loadingUserThreads.getOrCreate(queryKey).waitUntilLoaded()
     // NOTE: Deliberately *not* using a dependency array here!
     //
     // It is important to call waitUntil on *every* render.
@@ -2270,17 +2145,8 @@ function useUserThreads_experimental(options = {
       poller.dec();
     };
   }, [poller]);
-  const getter = useCallback2(
-    () => store.getUserThreadsLoadingState(options.query),
-    [store, options.query]
-  );
-  return useSyncExternalStoreWithSelector(
-    store.subscribe1_threads,
-    getter,
-    getter,
-    identity,
-    shallow2
-    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
+  return useSignal(
+    store.outputs.loadingUserThreads.getOrCreate(queryKey).signal
   );
 }
 function useUserThreadsSuspense_experimental(options = {
@@ -2290,14 +2156,15 @@ function useUserThreadsSuspense_experimental(options = {
 }) {
   const client = useClient();
   const { store } = getLiveblocksExtrasForClient(client);
-  use(store.waitUntilUserThreadsLoaded(options.query));
+  const queryKey = makeUserThreadsQueryKey(options.query);
+  use(store.outputs.loadingUserThreads.getOrCreate(queryKey).waitUntilLoaded());
   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(), identity, shallow4);
+  return useInboxNotifications_withClient(useClient(), identity2, shallow4);
 }
 function useInboxNotificationsSuspense() {
   return useInboxNotificationsSuspense_withClient(useClient());
@@ -2484,18 +2351,6 @@ var UpdateNotificationSettingsError = class extends Error {
   }
 };
 
-// src/use-signal.ts
-var identity2 = (value) => value;
-function useSignal(signal, selector, isEqual) {
-  return useSyncExternalStoreWithSelector(
-    signal.subscribe,
-    signal.get,
-    signal.get,
-    selector ?? identity2,
-    isEqual
-  );
-}
-
 // src/room.tsx
 import { shallow as shallow5 } from "@liveblocks/client";
 import {
@@ -2503,10 +2358,11 @@ import {
   console as console3,
   createCommentId,
   createThreadId,
+  DefaultMap as DefaultMap2,
   errorIf,
   HttpError as HttpError2,
   kInternal as kInternal3,
-  makeEventSource as makeEventSource2,
+  makeEventSource,
   makePoller as makePoller2,
   ServerMsgCode
 } from "@liveblocks/core";
@@ -2628,7 +2484,7 @@ function getRoomExtrasForClient(client) {
 }
 function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
-  const commentsErrorEventSource = makeEventSource2();
+  const commentsErrorEventSource = makeEventSource();
   function onMutationFailure(innerError, optimisticId, createPublicError) {
     store.optimisticUpdates.remove(optimisticId);
     if (innerError instanceof HttpError2) {
@@ -2642,73 +2498,59 @@ function makeRoomExtrasForClient(client) {
     }
     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;
-  }
+  const threadsPollersByRoomId = new DefaultMap2(
+    (roomId) => 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 }
+    )
+  );
+  const versionsPollersByRoomId = new DefaultMap2(
+    (roomId) => 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 }
+    )
+  );
+  const roomNotificationSettingsPollersByRoomId = new DefaultMap2(
+    (roomId) => 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 }
+    )
+  );
   return {
     store,
     commentsErrorEventSource: commentsErrorEventSource.observable,
     onMutationFailure,
-    getOrCreateThreadsPollerForRoomId,
-    getOrCreateVersionsPollerForRoomId,
-    getOrCreateNotificationsSettingsPollerForRoomId
+    getOrCreateThreadsPollerForRoomId: threadsPollersByRoomId.getOrCreate.bind(
+      threadsPollersByRoomId
+    ),
+    getOrCreateVersionsPollerForRoomId: versionsPollersByRoomId.getOrCreate.bind(versionsPollersByRoomId),
+    getOrCreateNotificationsSettingsPollerForRoomId: roomNotificationSettingsPollersByRoomId.getOrCreate.bind(
+      roomNotificationSettingsPollersByRoomId
+    )
   };
 }
 function makeRoomContextBundle(client) {
@@ -2887,7 +2729,7 @@ function RoomProviderInner(props) {
         return;
       }
       const { thread, inboxNotification: maybeNotification } = info;
-      const existingThread = store.get1_threads().threadsDB.getEvenIfDeleted(message.threadId);
+      const existingThread = store.outputs.threads.get().getEvenIfDeleted(message.threadId);
       switch (message.type) {
         case ServerMsgCode.COMMENT_EDITED:
         case ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -3258,18 +3100,15 @@ function useMutation(callback, deps) {
     [room, ...deps]
   );
 }
-function useThreads(options = {
-  query: { metadata: {} }
-}) {
+function useThreads(options = {}) {
   const { scrollOnLoad = true } = options;
   const client = useClient();
   const room = useRoom();
   const { store, getOrCreateThreadsPollerForRoomId } = getRoomExtrasForClient(client);
+  const queryKey = makeRoomThreadsQueryKey(room.id, options.query);
   const poller = getOrCreateThreadsPollerForRoomId(room.id);
   useEffect5(
-    () => {
-      void store.waitUntilRoomThreadsLoaded(room.id, options.query);
-    }
+    () => void store.outputs.loadingRoomThreads.getOrCreate(queryKey).waitUntilLoaded()
     // NOTE: Deliberately *not* using a dependency array here!
     //
     // It is important to call waitUntil on *every* render.
@@ -3284,20 +3123,11 @@ function useThreads(options = {
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = useCallback3(
-    () => store.getRoomThreadsLoadingState(room.id, options.query),
-    [store, room.id, options.query]
-  );
-  const state = useSyncExternalStoreWithSelector(
-    store.subscribe1_threads,
-    getter,
-    getter,
-    identity3,
-    shallow2
-    // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
+  const result = useSignal(
+    store.outputs.loadingRoomThreads.getOrCreate(queryKey).signal
   );
-  useScrollToCommentOnLoadEffect(scrollOnLoad, state);
-  return state;
+  useScrollToCommentOnLoadEffect(scrollOnLoad, result);
+  return result;
 }
 function useCommentsErrorListener(callback) {
   const client = useClient();
@@ -3385,7 +3215,7 @@ function useDeleteRoomThread(roomId) {
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const userId = getCurrentUserId(client);
-      const existing = store.get1_threads().threadsDB.get(threadId);
+      const existing = store.outputs.threads.get().get(threadId);
       if (existing?.comments?.[0]?.userId !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
@@ -3503,7 +3333,7 @@ function useEditRoomComment(roomId) {
     ({ threadId, commentId, body, attachments }) => {
       const editedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const existing = store.get1_threads().threadsDB.getEvenIfDeleted(threadId);
+      const existing = store.outputs.threads.get().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.`
@@ -3680,7 +3510,7 @@ function useMarkRoomThreadAsRead(roomId) {
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const inboxNotification = Object.values(
-        store.get1_notifications().notificationsById
+        store.outputs.notifications.get().notificationsById
       ).find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
@@ -3818,9 +3648,7 @@ function useRoomNotificationSettings() {
   const { store, getOrCreateNotificationsSettingsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateNotificationsSettingsPollerForRoomId(room.id);
   useEffect5(
-    () => {
-      void store.waitUntilRoomNotificationSettingsLoaded(room.id);
-    }
+    () => void store.outputs.settingsByRoomId.getOrCreate(room.id).waitUntilLoaded()
     // NOTE: Deliberately *not* using a dependency array here!
     //
     // It is important to call waitUntil on *every* render.
@@ -3837,16 +3665,8 @@ function useRoomNotificationSettings() {
       poller.dec();
     };
   }, [poller]);
-  const getter = useCallback3(
-    () => store.getNotificationSettingsLoadingState(room.id),
-    [store, room.id]
-  );
-  const settings = useSyncExternalStoreWithSelector(
-    store.subscribe2,
-    getter,
-    getter,
-    identity3,
-    shallow2
+  const settings = useSignal(
+    store.outputs.settingsByRoomId.getOrCreate(room.id).signal
   );
   return useMemo3(() => {
     return [settings, updateRoomNotificationSettings];
@@ -3856,7 +3676,7 @@ function useRoomNotificationSettingsSuspense() {
   const client = useClient();
   const store = getRoomExtrasForClient(client).store;
   const room = useRoom();
-  use(store.waitUntilRoomNotificationSettingsLoaded(room.id));
+  use(store.outputs.settingsByRoomId.getOrCreate(room.id).waitUntilLoaded());
   const [settings, updateRoomNotificationSettings] = useRoomNotificationSettings();
   assert2(!settings.error, "Did not expect error");
   assert2(!settings.isLoading, "Did not expect loading");
@@ -3903,14 +3723,8 @@ function useHistoryVersions() {
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = useCallback3(
-    () => store.getRoomVersionsLoadingState(room.id),
-    [store, room.id]
-  );
   useEffect5(
-    () => {
-      void store.waitUntilRoomVersionsLoaded(room.id);
-    }
+    () => void store.outputs.versionsByRoomId.getOrCreate(room.id).waitUntilLoaded()
     // NOTE: Deliberately *not* using a dependency array here!
     //
     // It is important to call waitUntil on *every* render.
@@ -3920,20 +3734,13 @@ function useHistoryVersions() {
     // 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 = useSyncExternalStoreWithSelector(
-    store.subscribe3,
-    getter,
-    getter,
-    identity3,
-    shallow2
-  );
-  return state;
+  return useSignal(store.outputs.versionsByRoomId.getOrCreate(room.id).signal);
 }
 function useHistoryVersionsSuspense() {
   const client = useClient();
   const room = useRoom();
   const store = getRoomExtrasForClient(client).store;
-  use(store.waitUntilRoomVersionsLoaded(room.id));
+  use(store.outputs.versionsByRoomId.getOrCreate(room.id).waitUntilLoaded());
   const result = useHistoryVersions();
   assert2(!result.error, "Did not expect error");
   assert2(!result.isLoading, "Did not expect loading");
@@ -4020,13 +3827,12 @@ function useStorageStatusSuspense(options) {
   useSuspendUntilStorageReady();
   return useStorageStatus(options);
 }
-function useThreadsSuspense(options = {
-  query: { metadata: {} }
-}) {
+function useThreadsSuspense(options = {}) {
   const client = useClient();
   const room = useRoom();
   const { store } = getRoomExtrasForClient(client);
-  use(store.waitUntilRoomThreadsLoaded(room.id, options.query));
+  const queryKey = makeRoomThreadsQueryKey(room.id, options.query);
+  use(store.outputs.loadingRoomThreads.getOrCreate(queryKey).waitUntilLoaded());
   const result = useThreads(options);
   assert2(!result.error, "Did not expect error");
   assert2(!result.isLoading, "Did not expect loading");
@@ -4053,11 +3859,11 @@ function useRoomAttachmentUrl(attachmentId, roomId) {
   const client = useClient();
   const store = client[kInternal3].httpClient.getOrCreateAttachmentUrlsStore(roomId);
   const getAttachmentUrlState = useCallback3(
-    () => store.getState(attachmentId),
+    () => store.getItemState(attachmentId),
     [store, attachmentId]
   );
   useEffect5(() => {
-    void store.get(attachmentId);
+    void store.enqueue(attachmentId);
   }, [store, attachmentId]);
   return useSyncExternalStoreWithSelector(
     store.subscribe,
@@ -4071,12 +3877,12 @@ function useAttachmentUrlSuspense(attachmentId) {
   const room = useRoom();
   const { attachmentUrlsStore } = room[kInternal3];
   const getAttachmentUrlState = useCallback3(
-    () => attachmentUrlsStore.getState(attachmentId),
+    () => attachmentUrlsStore.getItemState(attachmentId),
     [attachmentUrlsStore, attachmentId]
   );
   const attachmentUrlState = getAttachmentUrlState();
   if (!attachmentUrlState || attachmentUrlState.isLoading) {
-    throw attachmentUrlsStore.get(attachmentId);
+    throw attachmentUrlsStore.enqueue(attachmentId);
   }
   if (attachmentUrlState.error) {
     throw attachmentUrlState.error;
@@ -4095,12 +3901,13 @@ function useAttachmentUrlSuspense(attachmentId) {
     error: void 0
   };
 }
+var NO_PERMISSIONS = /* @__PURE__ */ new Set();
 function useRoomPermissions(roomId) {
   const client = useClient();
   const store = getRoomExtrasForClient(client).store;
   return useSignal(
     store.permissionHints.signal,
-    (hints) => hints[roomId] ?? /* @__PURE__ */ new Set()
+    (hints) => hints.get(roomId) ?? NO_PERMISSIONS
   );
 }
 function createRoomContext(client) {
@@ -4149,6 +3956,7 @@ export {
   RoomContext,
   useRoomOrNull,
   useSyncExternalStoreWithSelector,
+  useSignal,
   ClientContext,
   getUmbrellaStoreForClient,
   useClientOrNull,
@@ -4172,7 +3980,6 @@ export {
   _useUserThreadsSuspense_experimental,
   useSyncStatus,
   CreateThreadError,
-  useSignal,
   useStatus,
   useReportTextEditor,
   useYjsProvider,
@@ -4250,4 +4057,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-GMKB6I6V.mjs.map
+//# sourceMappingURL=chunk-EEYUKRIA.mjs.map