@liveblocks/react 2.15.1 → 2.16.0-rc1

package/dist/{chunk-NUDMG62P.js → chunk-NZL5WL5O.js}

@@ -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,
+    _nullishCoalesce(selector, () => ( identity)),
+    isEqual
+  );
+}
+
 // src/liveblocks.tsx
 
 
@@ -121,19 +133,30 @@ var config = {
   NOTIFICATION_SETTINGS_MAX_STALE_TIME: 5 * SECONDS
 };
 
-// src/lib/shallow2.ts
+// 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 });
+  }
+}
 
-function shallow2(a, b) {
-  if (!_core.isPlainObject.call(void 0, a) || !_core.isPlainObject.call(void 0, b)) {
-    return _core.shallow.call(void 0, a, b);
+// src/lib/itertools.ts
+function find(it, predicate) {
+  for (const item of it) {
+    if (predicate(item)) return item;
   }
-  const keysA = Object.keys(a);
-  if (keysA.length !== Object.keys(b).length) {
-    return false;
+  return void 0;
+}
+function count(it, predicate) {
+  let total = 0;
+  for (const item of it) {
+    if (predicate(item)) total++;
   }
-  return keysA.every(
-    (key) => Object.prototype.hasOwnProperty.call(b, key) && _core.shallow.call(void 0, a[key], b[key])
-  );
+  return total;
 }
 
 // src/lib/use-initial.ts
@@ -210,7 +233,6 @@ var use = (
 
 
 
-
 // src/lib/autobind.ts
 function autobind(self) {
   const seen = /* @__PURE__ */ new Set();
@@ -228,27 +250,26 @@ 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
+
+function shallow2(a, b) {
+  if (!_core.isPlainObject.call(void 0, a) || !_core.isPlainObject.call(void 0, b)) {
+    return _core.shallow.call(void 0, a, b);
   }
-  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) && _core.shallow.call(void 0, a[key], b[key])
+  );
 }
 
 // src/ThreadDB.ts
 
 
-// src/lib/guards.ts
-
-function isStartsWith(blob) {
-  return _core.isPlainObject.call(void 0, blob) && isString(blob.startsWith);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-
 // src/lib/querying.ts
+
 function makeThreadsFilter(query) {
   return (thread) => matchesQuery(thread, query) && matchesMetadata(thread, query);
 }
@@ -259,17 +280,17 @@ function matchesMetadata(thread, q) {
   const metadata = thread.metadata;
   return q.metadata === void 0 || Object.entries(q.metadata).every(
     ([key, op]) => (
-      // NOTE: `op` can be explicitly-`undefined` here, which ideally would not
-      // mean "filter for absence" like it does now, as this does not match the
-      // backend behavior at the moment. For an in-depth discussion, see
-      // https://liveblocks.slack.com/archives/C02PZL7QAAW/p1728546988505989
-      matchesOperator(metadata[key], op)
+      // Ignore explicit-undefined filters
+      // Boolean logic: op? => value matches the operator
+      op === void 0 || matchesOperator(metadata[key], op)
     )
   );
 }
 function matchesOperator(value, op) {
-  if (isStartsWith(op)) {
-    return isString(value) && value.startsWith(op.startsWith);
+  if (op === null) {
+    return value === void 0;
+  } else if (_core.isStartsWithOperator.call(void 0, op)) {
+    return typeof value === "string" && value.startsWith(op.startsWith);
   } else {
     return value === op;
   }
@@ -355,12 +376,12 @@ var ThreadDB = class _ThreadDB {
       this.upsert(thread);
     }
   }
-  applyDelta(updates) {
+  applyDelta(newThreads, deletedThreads) {
     _core.batch.call(void 0, () => {
-      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 +422,10 @@ var ThreadDB = class _ThreadDB {
 
 // src/umbrella-store.ts
 function makeRoomThreadsQueryKey(roomId, query) {
-  return `${roomId}-${_core.stringify.call(void 0, _nullishCoalesce(query, () => ( {})))}`;
+  return _core.stringify.call(void 0, [roomId, _nullishCoalesce(query, () => ( {}))]);
 }
 function makeUserThreadsQueryKey(query) {
-  return `USER_THREADS:${_core.stringify.call(void 0, _nullishCoalesce(query, () => ( {})))}`;
-}
-function makeNotificationSettingsQueryKey(roomId) {
-  return `${roomId}:NOTIFICATION_SETTINGS`;
-}
-function makeVersionsQueryKey(roomId) {
-  return `${roomId}-VERSIONS`;
+  return _core.stringify.call(void 0, _nullishCoalesce(query, () => ( {})));
 }
 function usify(promise) {
   if ("status" in promise) {
@@ -431,53 +446,50 @@ function usify(promise) {
   return usable;
 }
 var noop2 = Promise.resolve();
-var ASYNC_LOADING = Object.freeze({ isLoading: true });
 var PaginatedResource = class {
+  #signal;
   
-  #eventSource;
   #fetchPage;
-  #paginationState;
-  // Should be null while in loading or error state!
   #pendingFetchMore;
   constructor(fetchPage) {
-    this.#paginationState = null;
+    this.#signal = new (0, _core.Signal)(ASYNC_LOADING);
     this.#fetchPage = fetchPage;
-    this.#eventSource = _core.makeEventSource.call(void 0, );
     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 (!_optionalChain([state, 'optionalAccess', _3 => _3.cursor])) {
+    const state = this.#signal.get();
+    if (!_optionalChain([state, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.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 (_optionalChain([state, 'optionalAccess', _4 => _4.cursor]) === null) {
-      return noop2;
-    }
+    const state = this.#signal.get();
+    if (!_optionalChain([state, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.cursor])) return noop2;
     if (!this.#pendingFetchMore) {
       this.#pendingFetchMore = this.#fetchMore().finally(() => {
         this.#pendingFetchMore = null;
@@ -485,31 +497,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 = _core.autoRetry.call(void 0, 
+    const initialPageFetch$ = _core.autoRetry.call(void 0, 
       () => this.#fetchPage(
         /* cursor */
         void 0
@@ -517,67 +510,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 {
+  #signal;
   
-  #eventSource;
   #fetchPage;
   constructor(fetchPage) {
+    this.#signal = new (0, _core.Signal)(ASYNC_LOADING);
+    this.signal = this.#signal.asReadonly();
     this.#fetchPage = fetchPage;
-    this.#eventSource = _core.makeEventSource.call(void 0, );
-    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 = _core.autoRetry.call(void 0, 
+    const initialFetcher$ = _core.autoRetry.call(void 0, 
       () => 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 +600,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 +634,11 @@ function createStore_forNotifications() {
       return true;
     });
   }
+  function upsert(notification) {
+    signal.mutate((lut) => {
+      lut.set(notification.id, notification);
+    });
+  }
   return {
     signal: signal.asReadonly(),
     // Mutations
@@ -653,66 +648,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 (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
+function createStore_forRoomNotificationSettings(updates) {
+  const baseSignal = new (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
   function update(roomId, settings) {
-    signal.mutate((lut) => {
+    baseSignal.mutate((lut) => {
       lut.set(roomId, settings);
     });
   }
   return {
-    signal: signal.asReadonly(),
+    signal: _core.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 (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
+  const baseSignal = new (0, _core.MutableSignal)(
+    new (0, _core.DefaultMap)(() => /* @__PURE__ */ new Map())
+  );
   function update(roomId, versions) {
-    signal.mutate((lut) => {
-      const versionsById = _nullishCoalesce(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: _core.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 (0, _core.Signal)({});
+  const signal = new (0, _core.MutableSignal)(
+    new (0, _core.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 = _nullishCoalesce(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 +735,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 +785,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.
-  //
   
   // 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[_core.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 = _core.DerivedSignal.from(
       this.threads.signal,
@@ -837,13 +823,7 @@ var UmbrellaStore = class {
       this.optimisticUpdates.signal,
       (ts, ns, updates) => applyOptimisticUpdates_forThreadifications(ts, ns, updates)
     );
-    const threads = _core.DerivedSignal.from(
-      threadifications,
-      (s) => ({
-        threadsDB: s.threadsDB
-      }),
-      _core.shallow
-    );
+    const threads = _core.DerivedSignal.from(threadifications, (s) => s.threadsDB);
     const notifications = _core.DerivedSignal.from(
       threadifications,
       (s) => ({
@@ -852,177 +832,174 @@ var UmbrellaStore = class {
       }),
       _core.shallow
     );
-    const settingsByRoomId = _core.DerivedSignal.from(
-      this.roomNotificationSettings.signal,
-      this.optimisticUpdates.signal,
-      (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
+    const loadingUserThreads = new (0, _core.DefaultMap)(
+      (queryKey) => {
+        const query = JSON.parse(queryKey);
+        const resource = new PaginatedResource(async (cursor) => {
+          const result = await this.#client[_core.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 = _core.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
+            _nullishCoalesce(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 = _core.DerivedSignal.from(
-      this.historyVersions.signal,
-      (hv) => Object.fromEntries(
-        [...hv].map(([roomId, versions]) => [
-          roomId,
-          Object.fromEntries(versions)
-        ])
-      )
+    const loadingRoomThreads = new (0, _core.DefaultMap)(
+      (queryKey) => {
+        const [roomId, query] = JSON.parse(queryKey);
+        const resource = new PaginatedResource(async (cursor) => {
+          const result = await this.#client[_core.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 = _core.DerivedSignal.from(() => {
+          const result = resource.get();
+          if (result.isLoading || result.error) {
+            return result;
+          }
+          const threads2 = this.outputs.threads.get().findMany(roomId, _nullishCoalesce(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: _core.DerivedSignal.from(() => {
+        const resource = this.#notificationsPaginationState;
+        const result = resource.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 (0, _core.DefaultMap)((roomId) => {
+      const resource = new SinglePageResource(async () => {
+        const room = this.#client.getRoom(roomId);
+        if (room === null) {
+          throw new Error(`Room '${roomId}' is not available on client`);
+        }
+        const result = await room.getNotificationSettings();
+        this.roomNotificationSettings.update(roomId, result);
+      });
+      const signal = _core.DerivedSignal.from(() => {
+        const result = resource.get();
+        if (result.isLoading || result.error) {
+          return result;
+        } else {
+          return ASYNC_OK(
+            "settings",
+            _core.nn.call(void 0, this.roomNotificationSettings.signal.get()[roomId])
+          );
+        }
+      }, _core.shallow);
+      return { signal, waitUntilLoaded: resource.waitUntilLoaded };
+    });
+    const versionsByRoomId = new (0, _core.DefaultMap)(
+      (roomId) => {
+        const resource = new SinglePageResource(async () => {
+          const room = this.#client.getRoom(roomId);
+          if (room === null) {
+            throw new Error(`Room '${roomId}' is not available on client`);
+          }
+          const result = await room[_core.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 = _core.DerivedSignal.from(() => {
+          const result = resource.get();
+          if (result.isLoading || result.error) {
+            return result;
+          } else {
+            return ASYNC_OK(
+              "versions",
+              Object.values(_nullishCoalesce(this.historyVersions.signal.get()[roomId], () => ( {})))
+            );
+          }
+        }, _core.shallow);
+        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,
-      _nullishCoalesce(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
-      _nullishCoalesce(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: _core.nn.call(void 0, 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(_nullishCoalesce(this.get3()[roomId], () => ( {})))
-    };
-  }
-  /** @internal - Only call this method from unit tests. */
-  force_set_versions(callback) {
-    _core.batch.call(void 0, () => {
-      this.historyVersions.force_set(callback);
-      this.invalidateEntireStore();
-    });
-  }
-  /** @internal - Only call this method from unit tests. */
-  force_set_notifications(callback) {
-    _core.batch.call(void 0, () => {
-      this.notifications.force_set(callback);
-      this.invalidateEntireStore();
-    });
-  }
   /**
    * Updates an existing inbox notification with a new value, replacing the
    * corresponding optimistic update.
@@ -1164,7 +1141,7 @@ var UmbrellaStore = class {
   }
   updateThreadifications(threads, notifications, deletedThreads = [], deletedNotifications = []) {
     _core.batch.call(void 0, () => {
-      this.threads.applyDelta({ newThreads: threads, deletedThreads });
+      this.threads.applyDelta(threads, deletedThreads);
       this.notifications.applyDelta(notifications, deletedNotifications);
     });
   }
@@ -1197,39 +1174,6 @@ var UmbrellaStore = class {
       result.inboxNotifications.deleted
     );
   }
-  waitUntilNotificationsLoaded() {
-    return this.#notifications.waitUntilLoaded();
-  }
-  waitUntilRoomThreadsLoaded(roomId, query) {
-    const threadsFetcher = async (cursor) => {
-      const result = await this.#client[_core.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 +1195,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[_core.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() {
-    _core.batch.call(void 0, () => {
-      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 +1215,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 (0, _core.HttpError)(
-            `Room '${roomId}' is not available on client`,
-            479
-          );
-        }
-        const result = await room[_core.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 +1233,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 (0, _core.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 = _core.nn.call(void 0, 
       this.#client.getRoom(roomId),
@@ -1620,7 +1464,7 @@ function applyUpsertComment(thread, comment) {
       updatedAt: new Date(
         Math.max(
           thread.updatedAt.getTime(),
-          _optionalChain([comment, 'access', _5 => _5.editedAt, 'optionalAccess', _6 => _6.getTime, 'call', _7 => _7()]) || comment.createdAt.getTime()
+          _optionalChain([comment, 'access', _7 => _7.editedAt, 'optionalAccess', _8 => _8.getTime, 'call', _9 => _9()]) || comment.createdAt.getTime()
         )
       ),
       comments: updatedComments
@@ -1760,32 +1604,26 @@ 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 || _optionalChain([state, 'optionalAccess', _8 => _8.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _10 => _10.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -1803,7 +1641,7 @@ function selectorFor_useUser(state, userId) {
   };
 }
 function selectorFor_useRoomInfo(state, roomId) {
-  if (state === void 0 || _optionalChain([state, 'optionalAccess', _9 => _9.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _11 => _11.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -1889,7 +1727,7 @@ function makeLiveblocksContextBundle(client) {
   const shared = createSharedContext(client);
   const bundle = {
     LiveblocksProvider: LiveblocksProvider2,
-    useInboxNotifications: () => useInboxNotifications_withClient(client, identity, _core.shallow),
+    useInboxNotifications: () => useInboxNotifications_withClient(client, identity2, _core.shallow),
     useUnreadInboxNotificationsCount: () => useUnreadInboxNotificationsCount_withClient(client),
     useMarkInboxNotificationAsRead: useMarkInboxNotificationAsRead2,
     useMarkAllInboxNotificationsAsRead: useMarkAllInboxNotificationsAsRead2,
@@ -1915,9 +1753,17 @@ function makeLiveblocksContextBundle(client) {
 }
 function useInboxNotifications_withClient(client, selector, isEqual) {
   const { store, notificationsPoller: poller } = getLiveblocksExtrasForClient(client);
-  _react.useEffect.call(void 0, () => {
-    void store.waitUntilNotificationsLoaded();
-  });
+  _react.useEffect.call(void 0, 
+    () => 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.
+  );
   _react.useEffect.call(void 0, () => {
     poller.inc();
     poller.pollNowIfStale();
@@ -1925,18 +1771,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, _core.shallow);
+  use(store.outputs.loadingNotifications.waitUntilLoaded());
+  const result = useInboxNotifications_withClient(client, identity2, _core.shallow);
   _core.assert.call(void 0, !result.error, "Did not expect error");
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   return result;
@@ -1950,7 +1794,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);
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   _core.assert.call(void 0, !result.error, "Did not expect error");
@@ -1974,8 +1818,15 @@ function useMarkInboxNotificationAsRead_withClient(client) {
             optimisticId
           );
         },
-        () => {
+        (err) => {
           store.optimisticUpdates.remove(optimisticId);
+          client[_core.kInternal].emitError(
+            {
+              type: "MARK_INBOX_NOTIFICATION_AS_READ_ERROR",
+              inboxNotificationId
+            },
+            err
+          );
         }
       );
     },
@@ -1994,8 +1845,13 @@ function useMarkAllInboxNotificationsAsRead_withClient(client) {
       () => {
         store.markAllInboxNotificationsRead(optimisticId, readAt);
       },
-      () => {
+      (err) => {
         store.optimisticUpdates.remove(optimisticId);
+        client[_core.kInternal].emitError(
+          // No roomId, threadId, commentId to include for this error
+          { type: "MARK_ALL_INBOX_NOTIFICATIONS_AS_READ_ERROR" },
+          err
+        );
       }
     );
   }, [client]);
@@ -2014,8 +1870,12 @@ function useDeleteInboxNotification_withClient(client) {
         () => {
           store.deleteInboxNotification(inboxNotificationId, optimisticId);
         },
-        () => {
+        (err) => {
           store.optimisticUpdates.remove(optimisticId);
+          client[_core.kInternal].emitError(
+            { type: "DELETE_INBOX_NOTIFICATION_ERROR", inboxNotificationId },
+            err
+          );
         }
       );
     },
@@ -2034,42 +1894,43 @@ function useDeleteAllInboxNotifications_withClient(client) {
       () => {
         store.deleteAllInboxNotifications(optimisticId);
       },
-      () => {
+      (err) => {
         store.optimisticUpdates.remove(optimisticId);
+        client[_core.kInternal].emitError(
+          { type: "DELETE_ALL_INBOX_NOTIFICATIONS_ERROR" },
+          err
+        );
       }
     );
   }, [client]);
 }
 function useInboxNotificationThread_withClient(client, inboxNotificationId) {
   const { store } = getLiveblocksExtrasForClient(client);
-  const getter = store.get1_both;
-  const selector = _react.useCallback.call(void 0, 
-    (state) => {
-      const inboxNotification = _nullishCoalesce(state.notificationsById[inboxNotificationId], () => ( _core.raise.call(void 0, `Inbox notification with ID "${inboxNotificationId}" not found`)));
-      if (inboxNotification.kind !== "thread") {
-        _core.raise.call(void 0, 
-          `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
-        );
-      }
-      const thread = _nullishCoalesce(state.threadsDB.get(inboxNotification.threadId), () => ( _core.raise.call(void 0, 
-        `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
+  return useSignal(
+    store.outputs.threadifications,
+    _react.useCallback.call(void 0, 
+      (state) => {
+        const inboxNotification = _nullishCoalesce(state.notificationsById[inboxNotificationId], () => ( _core.raise.call(void 0, 
+          `Inbox notification with ID "${inboxNotificationId}" not found`
+        )));
+        if (inboxNotification.kind !== "thread") {
+          _core.raise.call(void 0, 
+            `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
+          );
+        }
+        const thread = _nullishCoalesce(state.threadsDB.get(inboxNotification.threadId), () => ( _core.raise.call(void 0, 
+          `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[_core.kInternal].usersStore;
   const getUserState = _react.useCallback.call(void 0, 
-    () => usersStore.getState(userId),
+    () => usersStore.getItemState(userId),
     [usersStore, userId]
   );
   const selector = _react.useCallback.call(void 0, 
@@ -2083,20 +1944,29 @@ function useUser_withClient(client, userId) {
     selector,
     _core.shallow
   );
-  _react.useEffect.call(void 0, () => {
-    void usersStore.get(userId);
-  }, [usersStore, userId, result]);
+  _react.useEffect.call(void 0, 
+    () => 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[_core.kInternal].usersStore;
   const getUserState = _react.useCallback.call(void 0, 
-    () => 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 +1991,7 @@ function useUserSuspense_withClient(client, userId) {
 function useRoomInfo_withClient(client, roomId) {
   const roomsInfoStore = client[_core.kInternal].roomsInfoStore;
   const getRoomInfoState = _react.useCallback.call(void 0, 
-    () => roomsInfoStore.getState(roomId),
+    () => roomsInfoStore.getItemState(roomId),
     [roomsInfoStore, roomId]
   );
   const selector = _react.useCallback.call(void 0, 
@@ -2135,20 +2005,29 @@ function useRoomInfo_withClient(client, roomId) {
     selector,
     _core.shallow
   );
-  _react.useEffect.call(void 0, () => {
-    void roomsInfoStore.get(roomId);
-  }, [roomsInfoStore, roomId, result]);
+  _react.useEffect.call(void 0, 
+    () => 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[_core.kInternal].roomsInfoStore;
   const getRoomInfoState = _react.useCallback.call(void 0, 
-    () => 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;
@@ -2182,6 +2061,7 @@ function createSharedContext(client) {
       useUser: (userId) => useUser_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfo_withClient(client, roomId),
       useIsInsideRoom,
+      useErrorListener,
       useSyncStatus: useSyncStatus2
     },
     suspense: {
@@ -2189,13 +2069,14 @@ function createSharedContext(client) {
       useUser: (userId) => useUserSuspense_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfoSuspense_withClient(client, roomId),
       useIsInsideRoom,
+      useErrorListener,
       useSyncStatus: useSyncStatus2
     }
   };
 }
 function useEnsureNoLiveblocksProvider(options) {
   const existing = useClientOrNull();
-  if (!_optionalChain([options, 'optionalAccess', _10 => _10.allowNesting]) && existing !== null) {
+  if (!_optionalChain([options, 'optionalAccess', _12 => _12.allowNesting]) && existing !== null) {
     throw new Error(
       "You cannot nest multiple LiveblocksProvider instances in the same React tree."
     );
@@ -2243,17 +2124,12 @@ function LiveblocksProvider(props) {
 function createLiveblocksContext(client) {
   return getOrCreateContextBundle(client);
 }
-function useUserThreads_experimental(options = {
-  query: {
-    metadata: {}
-  }
-}) {
+function useUserThreads_experimental(options = {}) {
   const client = useClient();
   const { store, userThreadsPoller: poller } = getLiveblocksExtrasForClient(client);
+  const queryKey = makeUserThreadsQueryKey(options.query);
   _react.useEffect.call(void 0, 
-    () => {
-      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,34 +2146,22 @@ function useUserThreads_experimental(options = {
       poller.dec();
     };
   }, [poller]);
-  const getter = _react.useCallback.call(void 0, 
-    () => 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 = {
-  query: {
-    metadata: {}
-  }
-}) {
+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);
   _core.assert.call(void 0, !result.error, "Did not expect error");
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   return result;
 }
 function useInboxNotifications() {
-  return useInboxNotifications_withClient(useClient(), identity, _core.shallow);
+  return useInboxNotifications_withClient(useClient(), identity2, _core.shallow);
 }
 function useInboxNotificationsSuspense() {
   return useInboxNotificationsSuspense_withClient(useClient());
@@ -2346,7 +2210,7 @@ var _useUserSuspense = useUserSuspense;
 var _useUserThreads_experimental = useUserThreads_experimental;
 var _useUserThreadsSuspense_experimental = useUserThreadsSuspense_experimental;
 function useSyncStatus_withClient(client, options) {
-  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.smooth]), () => ( false)));
+  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.smooth]), () => ( false)));
   if (smooth) {
     return useSyncStatusSmooth_withClient(client);
   } else {
@@ -2385,114 +2249,12 @@ function useSyncStatusSmooth_withClient(client) {
 function useSyncStatus(options) {
   return useSyncStatus_withClient(useClient(), options);
 }
-
-// src/types/errors.ts
-var CreateThreadError = class extends Error {
-  constructor(cause, context) {
-    super("Create thread failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateThreadError";
-  }
-};
-var DeleteThreadError = class extends Error {
-  constructor(cause, context) {
-    super("Delete thread failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "DeleteThreadError";
-  }
-};
-var EditThreadMetadataError = class extends Error {
-  constructor(cause, context) {
-    super("Edit thread metadata failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditThreadMetadataError";
-  }
-};
-var MarkThreadAsResolvedError = class extends Error {
-  constructor(cause, context) {
-    super("Mark thread as resolved failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkThreadAsResolvedError";
-  }
-};
-var MarkThreadAsUnresolvedError = class extends Error {
-  constructor(cause, context) {
-    super("Mark thread as unresolved failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkThreadAsUnresolvedError";
-  }
-};
-var CreateCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Create comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateCommentError";
-  }
-};
-var EditCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Edit comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditCommentError";
-  }
-};
-var DeleteCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Delete comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "DeleteCommentError";
-  }
-};
-var AddReactionError = class extends Error {
-  constructor(cause, context) {
-    super("Add reaction failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "AddReactionError";
-  }
-};
-var RemoveReactionError = class extends Error {
-  constructor(cause, context) {
-    super("Remove reaction failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "RemoveReactionError";
-  }
-};
-var MarkInboxNotificationAsReadError = class extends Error {
-  constructor(cause, context) {
-    super("Mark inbox notification as read failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "MarkInboxNotificationAsReadError";
-  }
-};
-var UpdateNotificationSettingsError = class extends Error {
-  constructor(cause, context) {
-    super("Update notification settings failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "UpdateNotificationSettingsError";
-  }
-};
-
-// src/use-signal.ts
-var identity2 = (value) => value;
-function useSignal(signal, selector, isEqual) {
-  return useSyncExternalStoreWithSelector(
-    signal.subscribe,
-    signal.get,
-    signal.get,
-    _nullishCoalesce(selector, () => ( identity2)),
-    isEqual
+function useErrorListener(callback) {
+  const client = useClient();
+  const savedCallback = useLatest(callback);
+  _react.useEffect.call(void 0, 
+    () => client.events.error.subscribe((e) => savedCallback.current(e)),
+    [client, savedCallback]
   );
 }
 
@@ -2600,14 +2362,6 @@ function getCurrentUserId(client) {
   }
   return userId;
 }
-function handleApiError(err) {
-  const message = `Request failed with status ${err.status}: ${err.message}`;
-  if (_optionalChain([err, 'access', _12 => _12.details, 'optionalAccess', _13 => _13.error]) === "FORBIDDEN") {
-    const detailedMessage = [message, err.details.suggestion, err.details.docs].filter(Boolean).join("\n");
-    _core.console.error(detailedMessage);
-  }
-  return new Error(message);
-}
 var _extras2 = /* @__PURE__ */ new WeakMap();
 var _bundles2 = /* @__PURE__ */ new WeakMap();
 function getOrCreateRoomContextBundle(client) {
@@ -2628,87 +2382,74 @@ function getRoomExtrasForClient(client) {
 }
 function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
-  const commentsErrorEventSource = _core.makeEventSource.call(void 0, );
-  function onMutationFailure(innerError, optimisticId, createPublicError) {
+  function onMutationFailure(optimisticId, context, innerError) {
     store.optimisticUpdates.remove(optimisticId);
     if (innerError instanceof _core.HttpError) {
-      const error = handleApiError(innerError);
-      commentsErrorEventSource.notify(createPublicError(error));
-      return;
-    }
-    if (innerError instanceof _core.HttpError) {
-      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 = _core.makePoller.call(void 0, 
-        async (signal) => {
-          try {
-            return await store.fetchRoomThreadsDeltaUpdate(roomId, signal);
-          } catch (err) {
-            _core.console.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 = _core.makePoller.call(void 0, 
-        async (signal) => {
-          try {
-            return await store.fetchRoomVersionsDeltaUpdate(roomId, signal);
-          } catch (err) {
-            _core.console.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 = _core.makePoller.call(void 0, 
-        async (signal) => {
-          try {
-            return await store.refreshRoomNotificationSettings(roomId, signal);
-          } catch (err) {
-            _core.console.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);
+      if (innerError.status === 403) {
+        const detailedMessage = [
+          innerError.message,
+          _optionalChain([innerError, 'access', _14 => _14.details, 'optionalAccess', _15 => _15.suggestion]),
+          _optionalChain([innerError, 'access', _16 => _16.details, 'optionalAccess', _17 => _17.docs])
+        ].filter(Boolean).join("\n");
+        _core.console.error(detailedMessage);
+      }
+      client[_core.kInternal].emitError(context, innerError);
+    } else {
+      throw innerError;
     }
-    return poller;
   }
+  const threadsPollersByRoomId = new (0, _core.DefaultMap)(
+    (roomId) => _core.makePoller.call(void 0, 
+      async (signal) => {
+        try {
+          return await store.fetchRoomThreadsDeltaUpdate(roomId, signal);
+        } catch (err) {
+          _core.console.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 (0, _core.DefaultMap)(
+    (roomId) => _core.makePoller.call(void 0, 
+      async (signal) => {
+        try {
+          return await store.fetchRoomVersionsDeltaUpdate(roomId, signal);
+        } catch (err) {
+          _core.console.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 (0, _core.DefaultMap)(
+    (roomId) => _core.makePoller.call(void 0, 
+      async (signal) => {
+        try {
+          return await store.refreshRoomNotificationSettings(roomId, signal);
+        } catch (err) {
+          _core.console.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) {
@@ -2726,7 +2467,6 @@ function makeRoomContextBundle(client) {
     useBroadcastEvent,
     useOthersListener,
     useLostConnectionListener,
-    useErrorListener,
     useEventListener,
     useHistory,
     useUndo,
@@ -2772,7 +2512,6 @@ function makeRoomContextBundle(client) {
       useBroadcastEvent,
       useOthersListener,
       useLostConnectionListener,
-      useErrorListener,
       useEventListener,
       useHistory,
       useUndo,
@@ -2808,8 +2547,7 @@ function makeRoomContextBundle(client) {
       useRoomNotificationSettings: useRoomNotificationSettingsSuspense,
       useUpdateRoomNotificationSettings,
       ...shared.suspense
-    },
-    useCommentsErrorListener
+    }
   };
   return Object.defineProperty(bundle, _core.kInternal, {
     enumerable: false
@@ -2852,7 +2590,7 @@ function RoomProviderInner(props) {
         "RoomProvider id property is required. For more information: https://liveblocks.io/docs/errors/liveblocks-react/RoomProvider-id-property-is-required"
       );
     }
-    if (!isString(roomId)) {
+    if (typeof roomId !== "string") {
       throw new Error("RoomProvider id property should be a string.");
     }
     const majorReactVersion = parseInt(_react.version) || 1;
@@ -2887,7 +2625,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 _core.ServerMsgCode.COMMENT_EDITED:
         case _core.ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -3005,7 +2743,7 @@ function useMentionSuggestionsCache() {
   return client[_core.kInternal].mentionSuggestionsCache;
 }
 function useStorageStatus(options) {
-  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.smooth]), () => ( false)));
+  const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.smooth]), () => ( false)));
   if (smooth) {
     return useStorageStatusSmooth();
   } else {
@@ -3070,14 +2808,6 @@ function useLostConnectionListener(callback) {
     [room, savedCallback]
   );
 }
-function useErrorListener(callback) {
-  const room = useRoom();
-  const savedCallback = useLatest(callback);
-  _react.useEffect.call(void 0, 
-    () => room.events.error.subscribe((e) => savedCallback.current(e)),
-    [room, savedCallback]
-  );
-}
 function useEventListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
@@ -3258,18 +2988,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);
   _react.useEffect.call(void 0, 
-    () => {
-      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,28 +3011,11 @@ function useThreads(options = {
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = _react.useCallback.call(void 0, 
-    () => store.getRoomThreadsLoadingState(room.id, options.query),
-    [store, room.id, options.query]
+  const result = useSignal(
+    store.outputs.loadingRoomThreads.getOrCreate(queryKey).signal
   );
-  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!
-  );
-  useScrollToCommentOnLoadEffect(scrollOnLoad, state);
-  return state;
-}
-function useCommentsErrorListener(callback) {
-  const client = useClient();
-  const savedCallback = useLatest(callback);
-  const { commentsErrorEventSource } = getRoomExtrasForClient(client);
-  _react.useEffect.call(void 0, () => {
-    return commentsErrorEventSource.subscribe(savedCallback.current);
-  }, [savedCallback, commentsErrorEventSource]);
+  useScrollToCommentOnLoadEffect(scrollOnLoad, result);
+  return result;
 }
 function useCreateThread() {
   return useCreateRoomThread(useRoom().id);
@@ -3347,7 +3057,7 @@ function useCreateRoomThread(roomId) {
         thread: newThread,
         roomId
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _15 => _15.map, 'call', _16 => _16((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _19 => _19.map, 'call', _20 => _20((attachment) => attachment.id)]);
       client[_core.kInternal].httpClient.createThread({
         roomId,
         threadId,
@@ -3360,15 +3070,16 @@ function useCreateRoomThread(roomId) {
           store.createThread(optimisticId, thread);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (err2) => new CreateThreadError(err2, {
+          {
+            type: "CREATE_THREAD_ERROR",
             roomId,
             threadId,
             commentId,
             body,
             metadata
-          })
+          },
+          err
         )
       );
       return newThread;
@@ -3385,8 +3096,8 @@ function useDeleteRoomThread(roomId) {
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const userId = getCurrentUserId(client);
-      const existing = store.get1_threads().threadsDB.get(threadId);
-      if (_optionalChain([existing, 'optionalAccess', _17 => _17.comments, 'optionalAccess', _18 => _18[0], 'optionalAccess', _19 => _19.userId]) !== userId) {
+      const existing = store.outputs.threads.get().get(threadId);
+      if (_optionalChain([existing, 'optionalAccess', _21 => _21.comments, 'optionalAccess', _22 => _22[0], 'optionalAccess', _23 => _23.userId]) !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
       const optimisticId = store.optimisticUpdates.add({
@@ -3400,9 +3111,9 @@ function useDeleteRoomThread(roomId) {
           store.deleteThread(threadId, optimisticId);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (err2) => new DeleteThreadError(err2, { roomId, threadId })
+          { type: "DELETE_THREAD_ERROR", roomId, threadId },
+          err
         )
       );
     },
@@ -3435,13 +3146,14 @@ function useEditRoomThreadMetadata(roomId) {
           store.patchThread(threadId, optimisticId, { metadata: metadata2 }, updatedAt)
         ),
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new EditThreadMetadataError(error, {
+          {
+            type: "EDIT_THREAD_METADATA_ERROR",
             roomId,
             threadId,
             metadata
-          })
+          },
+          err
         )
       );
     },
@@ -3473,20 +3185,21 @@ function useCreateRoomComment(roomId) {
         type: "create-comment",
         comment
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _20 => _20.map, 'call', _21 => _21((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _24 => _24.map, 'call', _25 => _25((attachment) => attachment.id)]);
       client[_core.kInternal].httpClient.createComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (newComment) => {
           store.createComment(newComment, optimisticId);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (err2) => new CreateCommentError(err2, {
+          {
+            type: "CREATE_COMMENT_ERROR",
             roomId,
             threadId,
             commentId,
             body
-          })
+          },
+          err
         )
       );
       return comment;
@@ -3503,7 +3216,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) {
         _core.console.warn(
           `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
@@ -3528,20 +3241,15 @@ function useEditRoomComment(roomId) {
           attachments: _nullishCoalesce(attachments, () => ( []))
         }
       });
-      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _22 => _22.map, 'call', _23 => _23((attachment) => attachment.id)]);
+      const attachmentIds = _optionalChain([attachments, 'optionalAccess', _26 => _26.map, 'call', _27 => _27((attachment) => attachment.id)]);
       client[_core.kInternal].httpClient.editComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (editedComment) => {
           store.editComment(threadId, optimisticId, editedComment);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new EditCommentError(error, {
-            roomId,
-            threadId,
-            commentId,
-            body
-          })
+          { type: "EDIT_COMMENT_ERROR", roomId, threadId, commentId, body },
+          err
         )
       );
     },
@@ -3569,13 +3277,9 @@ function useDeleteRoomComment(roomId) {
           store.deleteComment(threadId, optimisticId, commentId, deletedAt);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new DeleteCommentError(error, {
-            roomId,
-            threadId,
-            commentId
-          })
+          { type: "DELETE_COMMENT_ERROR", roomId, threadId, commentId },
+          err
         )
       );
     },
@@ -3613,14 +3317,15 @@ function useAddRoomCommentReaction(roomId) {
           );
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new AddReactionError(error, {
+          {
+            type: "ADD_REACTION_ERROR",
             roomId,
             threadId,
             commentId,
             emoji
-          })
+          },
+          err
         )
       );
     },
@@ -3657,14 +3362,15 @@ function useRemoveRoomCommentReaction(roomId) {
           );
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new RemoveReactionError(error, {
+          {
+            type: "REMOVE_REACTION_ERROR",
             roomId,
             threadId,
             commentId,
             emoji
-          })
+          },
+          err
         )
       );
     },
@@ -3680,7 +3386,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
       );
@@ -3704,11 +3410,13 @@ function useMarkRoomThreadAsRead(roomId) {
         },
         (err) => {
           onMutationFailure(
-            err,
             optimisticId,
-            (error) => new MarkInboxNotificationAsReadError(error, {
+            {
+              type: "MARK_INBOX_NOTIFICATION_AS_READ_ERROR",
+              roomId,
               inboxNotificationId: inboxNotification.id
-            })
+            },
+            err
           );
           return;
         }
@@ -3741,12 +3449,9 @@ function useMarkRoomThreadAsResolved(roomId) {
           );
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new MarkThreadAsResolvedError(error, {
-            roomId,
-            threadId
-          })
+          { type: "MARK_THREAD_AS_RESOLVED_ERROR", roomId, threadId },
+          err
         )
       );
     },
@@ -3777,12 +3482,9 @@ function useMarkRoomThreadAsUnresolved(roomId) {
           );
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new MarkThreadAsUnresolvedError(error, {
-            roomId,
-            threadId
-          })
+          { type: "MARK_THREAD_AS_UNRESOLVED_ERROR", roomId, threadId },
+          err
         )
       );
     },
@@ -3818,9 +3520,7 @@ function useRoomNotificationSettings() {
   const { store, getOrCreateNotificationsSettingsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateNotificationsSettingsPollerForRoomId(room.id);
   _react.useEffect.call(void 0, 
-    () => {
-      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 +3537,8 @@ function useRoomNotificationSettings() {
       poller.dec();
     };
   }, [poller]);
-  const getter = _react.useCallback.call(void 0, 
-    () => 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 _react.useMemo.call(void 0, () => {
     return [settings, updateRoomNotificationSettings];
@@ -3856,7 +3548,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();
   _core.assert.call(void 0, !settings.error, "Did not expect error");
   _core.assert.call(void 0, !settings.isLoading, "Did not expect loading");
@@ -3903,14 +3595,8 @@ function useHistoryVersions() {
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = _react.useCallback.call(void 0, 
-    () => store.getRoomVersionsLoadingState(room.id),
-    [store, room.id]
-  );
   _react.useEffect.call(void 0, 
-    () => {
-      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 +3606,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();
   _core.assert.call(void 0, !result.error, "Did not expect error");
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
@@ -3955,11 +3634,9 @@ function useUpdateRoomNotificationSettings() {
           store.updateRoomNotificationSettings(room.id, optimisticId, settings2);
         },
         (err) => onMutationFailure(
-          err,
           optimisticId,
-          (error) => new UpdateNotificationSettingsError(error, {
-            roomId: room.id
-          })
+          { type: "UPDATE_NOTIFICATION_SETTINGS_ERROR", roomId: room.id },
+          err
         )
       );
     },
@@ -4020,20 +3697,19 @@ 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);
   _core.assert.call(void 0, !result.error, "Did not expect error");
   _core.assert.call(void 0, !result.isLoading, "Did not expect loading");
   return result;
 }
 function selectorFor_useAttachmentUrl(state) {
-  if (state === void 0 || _optionalChain([state, 'optionalAccess', _24 => _24.isLoading])) {
+  if (state === void 0 || _optionalChain([state, 'optionalAccess', _28 => _28.isLoading])) {
     return _nullishCoalesce(state, () => ( { isLoading: true }));
   }
   if (state.error) {
@@ -4053,11 +3729,11 @@ function useRoomAttachmentUrl(attachmentId, roomId) {
   const client = useClient();
   const store = client[_core.kInternal].httpClient.getOrCreateAttachmentUrlsStore(roomId);
   const getAttachmentUrlState = _react.useCallback.call(void 0, 
-    () => store.getState(attachmentId),
+    () => store.getItemState(attachmentId),
     [store, attachmentId]
   );
   _react.useEffect.call(void 0, () => {
-    void store.get(attachmentId);
+    void store.enqueue(attachmentId);
   }, [store, attachmentId]);
   return useSyncExternalStoreWithSelector(
     store.subscribe,
@@ -4071,12 +3747,12 @@ function useAttachmentUrlSuspense(attachmentId) {
   const room = useRoom();
   const { attachmentUrlsStore } = room[_core.kInternal];
   const getAttachmentUrlState = _react.useCallback.call(void 0, 
-    () => 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 +3771,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) => _nullishCoalesce(hints[roomId], () => ( /* @__PURE__ */ new Set()))
+    (hints) => _nullishCoalesce(hints.get(roomId), () => ( NO_PERMISSIONS))
   );
 }
 function createRoomContext(client) {
@@ -4247,7 +3924,5 @@ var _useUpdateMyPresence = useUpdateMyPresence;
 
 
 
-
-
-exports.RoomContext = RoomContext; exports.useRoomOrNull = useRoomOrNull; exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector; exports.ClientContext = ClientContext; exports.getUmbrellaStoreForClient = getUmbrellaStoreForClient; exports.useClientOrNull = useClientOrNull; exports.useClient = useClient; exports.LiveblocksProvider = LiveblocksProvider; exports.createLiveblocksContext = createLiveblocksContext; exports.useInboxNotifications = useInboxNotifications; exports.useInboxNotificationsSuspense = useInboxNotificationsSuspense; exports.useMarkAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead; exports.useMarkInboxNotificationAsRead = useMarkInboxNotificationAsRead; exports.useDeleteAllInboxNotifications = useDeleteAllInboxNotifications; exports.useDeleteInboxNotification = useDeleteInboxNotification; exports.useUnreadInboxNotificationsCount = useUnreadInboxNotificationsCount; exports.useUnreadInboxNotificationsCountSuspense = useUnreadInboxNotificationsCountSuspense; exports.useRoomInfo = useRoomInfo; exports.useRoomInfoSuspense = useRoomInfoSuspense; exports._useInboxNotificationThread = _useInboxNotificationThread; exports._useUser = _useUser; exports._useUserSuspense = _useUserSuspense; exports._useUserThreads_experimental = _useUserThreads_experimental; exports._useUserThreadsSuspense_experimental = _useUserThreadsSuspense_experimental; exports.useSyncStatus = useSyncStatus; exports.CreateThreadError = CreateThreadError; exports.useSignal = useSignal; exports.useStatus = useStatus; exports.useReportTextEditor = useReportTextEditor; exports.useYjsProvider = useYjsProvider; exports.useCreateTextMention = useCreateTextMention; exports.useDeleteTextMention = useDeleteTextMention; exports.useResolveMentionSuggestions = useResolveMentionSuggestions; exports.useMentionSuggestionsCache = useMentionSuggestionsCache; exports.useStorageStatus = useStorageStatus; exports.useBatch = useBatch; exports.useLostConnectionListener = useLostConnectionListener; exports.useErrorListener = useErrorListener; exports.useHistory = useHistory; exports.useUndo = useUndo; exports.useRedo = useRedo; exports.useCanUndo = useCanUndo; exports.useCanRedo = useCanRedo; exports.useOthersConnectionIds = useOthersConnectionIds; exports.useCommentsErrorListener = useCommentsErrorListener; exports.useCreateRoomThread = useCreateRoomThread; exports.useDeleteRoomThread = useDeleteRoomThread; exports.useEditRoomThreadMetadata = useEditRoomThreadMetadata; exports.useCreateComment = useCreateComment; exports.useCreateRoomComment = useCreateRoomComment; exports.useEditComment = useEditComment; exports.useEditRoomComment = useEditRoomComment; exports.useDeleteComment = useDeleteComment; exports.useDeleteRoomComment = useDeleteRoomComment; exports.useAddRoomCommentReaction = useAddRoomCommentReaction; exports.useRemoveReaction = useRemoveReaction; exports.useRemoveRoomCommentReaction = useRemoveRoomCommentReaction; exports.useMarkThreadAsRead = useMarkThreadAsRead; exports.useMarkRoomThreadAsRead = useMarkRoomThreadAsRead; exports.useMarkThreadAsResolved = useMarkThreadAsResolved; exports.useMarkRoomThreadAsResolved = useMarkRoomThreadAsResolved; exports.useMarkThreadAsUnresolved = useMarkThreadAsUnresolved; exports.useMarkRoomThreadAsUnresolved = useMarkRoomThreadAsUnresolved; exports.useThreadSubscription = useThreadSubscription; exports.useHistoryVersionData = useHistoryVersionData; exports.useUpdateRoomNotificationSettings = useUpdateRoomNotificationSettings; exports.useOthersConnectionIdsSuspense = useOthersConnectionIdsSuspense; exports.useStorageStatusSuspense = useStorageStatusSuspense; exports.useAttachmentUrl = useAttachmentUrl; exports.useRoomAttachmentUrl = useRoomAttachmentUrl; exports.useAttachmentUrlSuspense = useAttachmentUrlSuspense; exports.useRoomPermissions = useRoomPermissions; exports.createRoomContext = createRoomContext; exports._RoomProvider = _RoomProvider; exports._useBroadcastEvent = _useBroadcastEvent; exports._useOthersListener = _useOthersListener; exports._useRoom = _useRoom; exports._useIsInsideRoom = _useIsInsideRoom; exports._useAddReaction = _useAddReaction; exports._useMutation = _useMutation; exports._useCreateThread = _useCreateThread; exports._useDeleteThread = _useDeleteThread; exports._useEditThreadMetadata = _useEditThreadMetadata; exports._useEventListener = _useEventListener; exports._useMyPresence = _useMyPresence; exports._useOthersMapped = _useOthersMapped; exports._useOthersMappedSuspense = _useOthersMappedSuspense; exports._useThreads = _useThreads; exports._useThreadsSuspense = _useThreadsSuspense; exports._useRoomNotificationSettings = _useRoomNotificationSettings; exports._useRoomNotificationSettingsSuspense = _useRoomNotificationSettingsSuspense; exports._useHistoryVersions = _useHistoryVersions; exports._useHistoryVersionsSuspense = _useHistoryVersionsSuspense; exports._useOther = _useOther; exports._useOthers = _useOthers; exports._useOtherSuspense = _useOtherSuspense; exports._useOthersSuspense = _useOthersSuspense; exports._useStorage = _useStorage; exports._useStorageSuspense = _useStorageSuspense; exports._useSelf = _useSelf; exports._useSelfSuspense = _useSelfSuspense; exports._useStorageRoot = _useStorageRoot; exports._useUpdateMyPresence = _useUpdateMyPresence;
-//# sourceMappingURL=chunk-NUDMG62P.js.map
+exports.RoomContext = RoomContext; exports.useRoomOrNull = useRoomOrNull; exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector; exports.useSignal = useSignal; exports.ClientContext = ClientContext; exports.getUmbrellaStoreForClient = getUmbrellaStoreForClient; exports.useClientOrNull = useClientOrNull; exports.useClient = useClient; exports.LiveblocksProvider = LiveblocksProvider; exports.createLiveblocksContext = createLiveblocksContext; exports.useInboxNotifications = useInboxNotifications; exports.useInboxNotificationsSuspense = useInboxNotificationsSuspense; exports.useMarkAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead; exports.useMarkInboxNotificationAsRead = useMarkInboxNotificationAsRead; exports.useDeleteAllInboxNotifications = useDeleteAllInboxNotifications; exports.useDeleteInboxNotification = useDeleteInboxNotification; exports.useUnreadInboxNotificationsCount = useUnreadInboxNotificationsCount; exports.useUnreadInboxNotificationsCountSuspense = useUnreadInboxNotificationsCountSuspense; exports.useRoomInfo = useRoomInfo; exports.useRoomInfoSuspense = useRoomInfoSuspense; exports._useInboxNotificationThread = _useInboxNotificationThread; exports._useUser = _useUser; exports._useUserSuspense = _useUserSuspense; exports._useUserThreads_experimental = _useUserThreads_experimental; exports._useUserThreadsSuspense_experimental = _useUserThreadsSuspense_experimental; exports.useSyncStatus = useSyncStatus; exports.useErrorListener = useErrorListener; exports.useStatus = useStatus; exports.useReportTextEditor = useReportTextEditor; exports.useYjsProvider = useYjsProvider; exports.useCreateTextMention = useCreateTextMention; exports.useDeleteTextMention = useDeleteTextMention; exports.useResolveMentionSuggestions = useResolveMentionSuggestions; exports.useMentionSuggestionsCache = useMentionSuggestionsCache; exports.useStorageStatus = useStorageStatus; exports.useBatch = useBatch; exports.useLostConnectionListener = useLostConnectionListener; exports.useHistory = useHistory; exports.useUndo = useUndo; exports.useRedo = useRedo; exports.useCanUndo = useCanUndo; exports.useCanRedo = useCanRedo; exports.useOthersConnectionIds = useOthersConnectionIds; exports.useCreateRoomThread = useCreateRoomThread; exports.useDeleteRoomThread = useDeleteRoomThread; exports.useEditRoomThreadMetadata = useEditRoomThreadMetadata; exports.useCreateComment = useCreateComment; exports.useCreateRoomComment = useCreateRoomComment; exports.useEditComment = useEditComment; exports.useEditRoomComment = useEditRoomComment; exports.useDeleteComment = useDeleteComment; exports.useDeleteRoomComment = useDeleteRoomComment; exports.useAddRoomCommentReaction = useAddRoomCommentReaction; exports.useRemoveReaction = useRemoveReaction; exports.useRemoveRoomCommentReaction = useRemoveRoomCommentReaction; exports.useMarkThreadAsRead = useMarkThreadAsRead; exports.useMarkRoomThreadAsRead = useMarkRoomThreadAsRead; exports.useMarkThreadAsResolved = useMarkThreadAsResolved; exports.useMarkRoomThreadAsResolved = useMarkRoomThreadAsResolved; exports.useMarkThreadAsUnresolved = useMarkThreadAsUnresolved; exports.useMarkRoomThreadAsUnresolved = useMarkRoomThreadAsUnresolved; exports.useThreadSubscription = useThreadSubscription; exports.useHistoryVersionData = useHistoryVersionData; exports.useUpdateRoomNotificationSettings = useUpdateRoomNotificationSettings; exports.useOthersConnectionIdsSuspense = useOthersConnectionIdsSuspense; exports.useStorageStatusSuspense = useStorageStatusSuspense; exports.useAttachmentUrl = useAttachmentUrl; exports.useRoomAttachmentUrl = useRoomAttachmentUrl; exports.useAttachmentUrlSuspense = useAttachmentUrlSuspense; exports.useRoomPermissions = useRoomPermissions; exports.createRoomContext = createRoomContext; exports._RoomProvider = _RoomProvider; exports._useBroadcastEvent = _useBroadcastEvent; exports._useOthersListener = _useOthersListener; exports._useRoom = _useRoom; exports._useIsInsideRoom = _useIsInsideRoom; exports._useAddReaction = _useAddReaction; exports._useMutation = _useMutation; exports._useCreateThread = _useCreateThread; exports._useDeleteThread = _useDeleteThread; exports._useEditThreadMetadata = _useEditThreadMetadata; exports._useEventListener = _useEventListener; exports._useMyPresence = _useMyPresence; exports._useOthersMapped = _useOthersMapped; exports._useOthersMappedSuspense = _useOthersMappedSuspense; exports._useThreads = _useThreads; exports._useThreadsSuspense = _useThreadsSuspense; exports._useRoomNotificationSettings = _useRoomNotificationSettings; exports._useRoomNotificationSettingsSuspense = _useRoomNotificationSettingsSuspense; exports._useHistoryVersions = _useHistoryVersions; exports._useHistoryVersionsSuspense = _useHistoryVersionsSuspense; exports._useOther = _useOther; exports._useOthers = _useOthers; exports._useOtherSuspense = _useOtherSuspense; exports._useOthersSuspense = _useOthersSuspense; exports._useStorage = _useStorage; exports._useStorageSuspense = _useStorageSuspense; exports._useSelf = _useSelf; exports._useSelfSuspense = _useSelfSuspense; exports._useStorageRoot = _useStorageRoot; exports._useUpdateMyPresence = _useUpdateMyPresence;
+//# sourceMappingURL=chunk-NZL5WL5O.js.map