@liveblocks/react 2.15.0-debug1 → 2.15.0

package/dist/{chunk-UJLD6FYC.mjs → chunk-NZZCQLBR.mjs}

@@ -196,14 +196,14 @@ var use = (
 // src/umbrella-store.ts
 import {
   autoRetry,
-  batch,
+  batch as batch2,
   compactObject,
   console as console2,
   DerivedSignal,
   HttpError,
   kInternal,
   makeEventSource,
-  mapValues,
+  MutableSignal as MutableSignal2,
   nanoid,
   nn,
   Signal,
@@ -227,8 +227,16 @@ 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;
+  }
+  return void 0;
+}
+
 // src/ThreadDB.ts
-import { MutableSignal, SortedList } from "@liveblocks/core";
+import { batch, MutableSignal, SortedList } from "@liveblocks/core";
 
 // src/lib/guards.ts
 import { isPlainObject as isPlainObject2 } from "@liveblocks/core";
@@ -346,6 +354,18 @@ var ThreadDB = class _ThreadDB {
       this.upsert(thread);
     }
   }
+  applyDelta(updates) {
+    batch(() => {
+      for (const thread of updates.newThreads) {
+        this.upsertIfNewer(thread);
+      }
+      for (const { id, deletedAt } of updates.deletedThreads) {
+        const existing = this.getEvenIfDeleted(id);
+        if (!existing) continue;
+        this.delete(id, deletedAt);
+      }
+    });
+  }
   /**
    * Marks a thread as deleted. It will no longer pop up in .findMany()
    * queries, but it can still be accessed via `.getEvenIfDeleted()`.
@@ -533,14 +553,11 @@ var SinglePageResource = class {
     const usable = this.#cachedPromise;
     if (usable === null || usable.status === "pending") {
       return ASYNC_LOADING;
-    }
-    if (usable.status === "rejected") {
+    } else if (usable.status === "rejected") {
       return { isLoading: false, error: usable.reason };
+    } else {
+      return { isLoading: false, data: void 0 };
     }
-    return {
-      isLoading: false,
-      data: void 0
-    };
   }
   #cachedPromise = null;
   waitUntilLoaded() {
@@ -567,9 +584,164 @@ var SinglePageResource = class {
     return promise;
   }
 };
+function createStore_forNotifications() {
+  const signal = new MutableSignal2(/* @__PURE__ */ new Map());
+  function markRead(notificationId, readAt) {
+    signal.mutate((lut) => {
+      const existing = lut.get(notificationId);
+      if (!existing) {
+        return false;
+      }
+      lut.set(notificationId, { ...existing, readAt });
+      return true;
+    });
+  }
+  function markAllRead(readAt) {
+    return signal.mutate((lut) => {
+      for (const n of lut.values()) {
+        n.readAt = readAt;
+      }
+    });
+  }
+  function deleteOne(inboxNotificationId) {
+    signal.mutate((lut) => lut.delete(inboxNotificationId));
+  }
+  function clear() {
+    signal.mutate((lut) => lut.clear());
+  }
+  function applyDelta(newInboxNotifications, deletedNotifications) {
+    signal.mutate((lut) => {
+      let mutated = false;
+      for (const n of newInboxNotifications) {
+        const existing = lut.get(n.id);
+        if (existing) {
+          const result = compareInboxNotifications(existing, n);
+          if (result === 1) continue;
+        }
+        lut.set(n.id, n);
+        mutated = true;
+      }
+      for (const n of deletedNotifications) {
+        lut.delete(n.id);
+        mutated = true;
+      }
+      return mutated;
+    });
+  }
+  function updateAssociatedNotification(newComment) {
+    signal.mutate((lut) => {
+      const existing = find(
+        lut.values(),
+        (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
+      );
+      if (!existing) return false;
+      lut.set(existing.id, {
+        ...existing,
+        notifiedAt: newComment.createdAt,
+        readAt: newComment.createdAt
+      });
+      return true;
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    markAllRead,
+    markRead,
+    delete: deleteOne,
+    applyDelta,
+    clear,
+    updateAssociatedNotification,
+    // XXX_vincent Remove this eventually
+    force_set: (mutationCallback) => signal.mutate(mutationCallback),
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forRoomNotificationSettings() {
+  const signal = new MutableSignal2(/* @__PURE__ */ new Map());
+  function update(roomId, settings) {
+    signal.mutate((lut) => {
+      lut.set(roomId, settings);
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    update,
+    // XXX_vincent Remove this eventually
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forHistoryVersions() {
+  const signal = new MutableSignal2(/* @__PURE__ */ new Map());
+  function update(roomId, versions) {
+    signal.mutate((lut) => {
+      const versionsById = lut.get(roomId) ?? (lut.set(roomId, /* @__PURE__ */ new Map()), lut.get(roomId));
+      for (const version of versions) {
+        versionsById.set(version.id, version);
+      }
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    update,
+    // XXX_vincent Remove these eventually
+    force_set: (callback) => signal.mutate(callback),
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forPermissionHints() {
+  const signal = new Signal({});
+  function update(newHints) {
+    signal.set((prev) => {
+      const permissionsByRoom = { ...prev };
+      for (const [roomId, newPermissions] of Object.entries(newHints)) {
+        const existing = permissionsByRoom[roomId] ?? /* @__PURE__ */ new Set();
+        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 }))
+  };
+}
+function createStore_forOptimistic(client) {
+  const signal = new Signal([]);
+  const syncSource = client[kInternal].createSyncSource();
+  signal.subscribe(
+    () => syncSource.setSyncStatus(
+      signal.get().length > 0 ? "synchronizing" : "synchronized"
+    )
+  );
+  function add(optimisticUpdate) {
+    const id = nanoid();
+    const newUpdate = { ...optimisticUpdate, id };
+    signal.set((state) => [...state, newUpdate]);
+    return id;
+  }
+  function remove(optimisticId) {
+    signal.set((state) => state.filter((ou) => ou.id !== optimisticId));
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    add,
+    remove,
+    // XXX_vincent Remove this eventually
+    invalidate: () => signal.set((store) => [...store])
+  };
+}
 var UmbrellaStore = class {
   #client;
-  #syncSource;
   //
   // Internally, the UmbrellaStore keeps track of a few source signals that can
   // be set and mutated individually. When any of those are mutated then the
@@ -596,13 +768,17 @@ var UmbrellaStore = class {
   // Input signals.
   // (Can be mutated directly.)
   //
-  baseThreadsDB;
+  // XXX_vincent Now that we have createStore_forX, we should probably also change
+  // `threads` to this pattern, ie create a createStore_forThreads helper as
+  // well. It almost works like that already anyway!
+  threads;
   // Exposes its signal under `.signal` prop
-  baseNotificationsById;
-  baseSettingsByRoomId;
+  notifications;
+  roomNotificationSettings;
+  // prettier-ignore
+  historyVersions;
+  permissionHints;
   optimisticUpdates;
-  baseVersionsByRoomId;
-  permissionHintsByRoomId;
   //
   // Output signals.
   // (Readonly, clean, consistent. With optimistic updates applied.)
@@ -611,7 +787,7 @@ var UmbrellaStore = class {
   // threads and notifications separately, but the threadifications signal will
   // be updated whenever either of them change.
   //
-  // TODO(vincent+nimesh) APIs like getRoomThreadsLoadingState should really also be modeled as output signals.
+  // XXX_vincent APIs like getRoomThreadsLoadingState should really also be modeled as output signals.
   //
   outputs;
   // Notifications
@@ -631,13 +807,11 @@ var UmbrellaStore = class {
   #roomNotificationSettings = /* @__PURE__ */ new Map();
   constructor(client) {
     this.#client = client[kInternal].as();
-    this.#syncSource = this.#client[kInternal].createSyncSource();
+    this.optimisticUpdates = createStore_forOptimistic(this.#client);
+    this.permissionHints = createStore_forPermissionHints();
     const inboxFetcher = async (cursor) => {
       const result = await this.#client.getInboxNotifications({ cursor });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
+      this.updateThreadifications(result.threads, result.inboxNotifications);
       if (this.#notificationsLastRequestedAt === null) {
         this.#notificationsLastRequestedAt = result.requestedAt;
       }
@@ -652,16 +826,14 @@ var UmbrellaStore = class {
         this.invalidateEntireStore()
       )
     );
-    this.baseThreadsDB = new ThreadDB();
-    this.optimisticUpdates = new Signal([]);
-    this.baseVersionsByRoomId = new Signal({});
-    this.baseNotificationsById = new Signal({});
-    this.baseSettingsByRoomId = new Signal({});
-    this.permissionHintsByRoomId = new Signal({});
+    this.threads = new ThreadDB();
+    this.notifications = createStore_forNotifications();
+    this.roomNotificationSettings = createStore_forRoomNotificationSettings();
+    this.historyVersions = createStore_forHistoryVersions();
     const threadifications = DerivedSignal.from(
-      this.baseThreadsDB.signal,
-      this.baseNotificationsById,
-      this.optimisticUpdates,
+      this.threads.signal,
+      this.notifications.signal,
+      this.optimisticUpdates.signal,
       (ts, ns, updates) => applyOptimisticUpdates_forThreadifications(ts, ns, updates)
     );
     const threads = DerivedSignal.from(threadifications, (s) => ({
@@ -672,13 +844,18 @@ var UmbrellaStore = class {
       notificationsById: s.notificationsById
     }));
     const settingsByRoomId = DerivedSignal.from(
-      this.baseSettingsByRoomId,
-      this.optimisticUpdates,
+      this.roomNotificationSettings.signal,
+      this.optimisticUpdates.signal,
       (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
     );
     const versionsByRoomId = DerivedSignal.from(
-      this.baseVersionsByRoomId,
-      (hv) => hv
+      this.historyVersions.signal,
+      (hv) => Object.fromEntries(
+        [...hv].map(([roomId, versions]) => [
+          roomId,
+          Object.fromEntries(versions)
+        ])
+      )
     );
     this.outputs = {
       threadifications,
@@ -687,11 +864,6 @@ var UmbrellaStore = class {
       settingsByRoomId,
       versionsByRoomId
     };
-    this.optimisticUpdates.subscribe(
-      () => this.#syncSource.setSyncStatus(
-        this.optimisticUpdates.get().length > 0 ? "synchronizing" : "synchronized"
-      )
-    );
     autobind(this);
   }
   get1_both() {
@@ -797,7 +969,7 @@ var UmbrellaStore = class {
     };
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
-  // TODO(vincent+nimesh) This should really be a derived Signal!
+  // XXX_vincent This should really be a derived Signal!
   getNotificationSettingsLoadingState(roomId) {
     const queryKey = makeNotificationSettingsQueryKey(roomId);
     const resource = this.#roomNotificationSettings.get(queryKey);
@@ -828,48 +1000,17 @@ var UmbrellaStore = class {
       versions: Object.values(this.get3()[roomId] ?? {})
     };
   }
-  // Direct low-level cache mutations ------------------------------------------------- {{{
-  #mutateThreadsDB(mutate) {
-    batch(() => {
-      mutate(this.baseThreadsDB);
-    });
-  }
-  #updateInboxNotificationsCache(mapFn) {
-    this.baseNotificationsById.set((prev) => mapFn(prev));
-  }
-  #setNotificationSettings(roomId, settings) {
-    this.baseSettingsByRoomId.set((state) => ({
-      ...state,
-      [roomId]: settings
-    }));
-  }
-  #updateRoomVersions(roomId, versions) {
-    this.baseVersionsByRoomId.set((prev) => {
-      const newVersions = { ...prev[roomId] };
-      for (const version of versions) {
-        newVersions[version.id] = version;
-      }
-      return {
-        ...prev,
-        [roomId]: newVersions
-      };
-    });
-  }
-  #updateOptimisticUpdatesCache(mapFn) {
-    this.optimisticUpdates.set(mapFn);
-  }
-  // ---------------------------------------------------------------------------------- }}}
   /** @internal - Only call this method from unit tests. */
   force_set_versions(callback) {
-    batch(() => {
-      this.baseVersionsByRoomId.set(callback);
+    batch2(() => {
+      this.historyVersions.force_set(callback);
       this.invalidateEntireStore();
     });
   }
   /** @internal - Only call this method from unit tests. */
   force_set_notifications(callback) {
-    batch(() => {
-      this.baseNotificationsById.set(callback);
+    batch2(() => {
+      this.notifications.force_set(callback);
       this.invalidateEntireStore();
     });
   }
@@ -877,64 +1018,47 @@ var UmbrellaStore = class {
    * Updates an existing inbox notification with a new value, replacing the
    * corresponding optimistic update.
    *
-   * This will not update anything if the inbox notification ID isn't found in
-   * the cache.
+   * This will not update anything if the inbox notification ID isn't found.
    */
-  updateInboxNotification(inboxNotificationId, optimisticUpdateId, callback) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#updateInboxNotificationsCache((cache) => {
-        const existing = cache[inboxNotificationId];
-        if (!existing) {
-          return cache;
-        }
-        return {
-          ...cache,
-          [inboxNotificationId]: callback(existing)
-        };
-      });
+  markInboxNotificationRead(inboxNotificationId, readAt, optimisticId) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.markRead(inboxNotificationId, readAt);
     });
   }
-  /**
-   * Updates *all* inbox notifications by running a mapper function over all of
-   * them, replacing the corresponding optimistic update.
-   */
-  updateAllInboxNotifications(optimisticUpdateId, mapFn) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#updateInboxNotificationsCache((cache) => mapValues(cache, mapFn));
+  markAllInboxNotificationsRead(optimisticId, readAt) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.markAllRead(readAt);
     });
   }
   /**
    * Deletes an existing inbox notification, replacing the corresponding
    * optimistic update.
    */
-  deleteInboxNotification(inboxNotificationId, optimisticUpdateId) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#updateInboxNotificationsCache((cache) => {
-        const { [inboxNotificationId]: removed, ...newCache } = cache;
-        return removed === void 0 ? cache : newCache;
-      });
+  deleteInboxNotification(inboxNotificationId, optimisticId) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.delete(inboxNotificationId);
     });
   }
   /**
    * Deletes *all* inbox notifications, replacing the corresponding optimistic
    * update.
    */
-  deleteAllInboxNotifications(optimisticUpdateId) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#updateInboxNotificationsCache(() => ({}));
+  deleteAllInboxNotifications(optimisticId) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.clear();
     });
   }
   /**
    * Creates an new thread, replacing the corresponding optimistic update.
    */
-  createThread(optimisticUpdateId, thread) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#mutateThreadsDB((db) => db.upsert(thread));
+  createThread(optimisticId, thread) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.threads.upsert(thread);
     });
   }
   /**
@@ -942,44 +1066,43 @@ var UmbrellaStore = class {
    * optimistic update.
    *
    * This will not update anything if:
-   * - The thread ID isn't found in the cache; or
-   * - The thread ID was already deleted from the cache; or
-   * - The thread ID in the cache was updated more recently than the optimistic
-   *   update's timestamp (if given)
+   * - The thread ID isn't found; or
+   * - The thread ID was already deleted; or
+   * - The thread ID was updated more recently than the optimistic update's
+   *   timestamp (if given)
    */
-  #updateThread(threadId, optimisticUpdateId, callback, updatedAt) {
-    batch(() => {
-      if (optimisticUpdateId !== null) {
-        this.removeOptimisticUpdate(optimisticUpdateId);
+  #updateThread(threadId, optimisticId, callback, updatedAt) {
+    batch2(() => {
+      if (optimisticId !== null) {
+        this.optimisticUpdates.remove(optimisticId);
       }
-      this.#mutateThreadsDB((db) => {
-        const existing = db.get(threadId);
-        if (!existing) return;
-        if (!!updatedAt && existing.updatedAt > updatedAt) return;
-        db.upsert(callback(existing));
-      });
+      const db = this.threads;
+      const existing = db.get(threadId);
+      if (!existing) return;
+      if (!!updatedAt && existing.updatedAt > updatedAt) return;
+      db.upsert(callback(existing));
     });
   }
-  patchThread(threadId, optimisticUpdateId, patch, updatedAt) {
+  patchThread(threadId, optimisticId, patch, updatedAt) {
     return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => ({ ...thread, ...compactObject(patch) }),
       updatedAt
     );
   }
-  addReaction(threadId, optimisticUpdateId, commentId, reaction, createdAt) {
+  addReaction(threadId, optimisticId, commentId, reaction, createdAt) {
     this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyAddReaction(thread, commentId, reaction),
       createdAt
     );
   }
-  removeReaction(threadId, optimisticUpdateId, commentId, emoji, userId, removedAt) {
+  removeReaction(threadId, optimisticId, commentId, emoji, userId, removedAt) {
     this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyRemoveReaction(thread, commentId, emoji, userId, removedAt),
       removedAt
     );
@@ -989,13 +1112,13 @@ var UmbrellaStore = class {
    * replacing the corresponding optimistic update.
    *
    * This will not update anything if:
-   * - The thread ID isn't found in the cache; or
-   * - The thread ID was already deleted from the cache
+   * - The thread ID isn't found; or
+   * - The thread ID was already deleted
    */
-  deleteThread(threadId, optimisticUpdateId) {
+  deleteThread(threadId, optimisticId) {
     return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       // A deletion is actually an update of the deletedAt property internally
       (thread) => ({ ...thread, updatedAt: /* @__PURE__ */ new Date(), deletedAt: /* @__PURE__ */ new Date() })
     );
@@ -1004,94 +1127,48 @@ var UmbrellaStore = class {
    * Creates an existing comment and ensures the associated notification is
    * updated correctly, replacing the corresponding optimistic update.
    */
-  createComment(newComment, optimisticUpdateId) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      const existingThread = this.baseThreadsDB.get(newComment.threadId);
+  createComment(newComment, optimisticId) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      const existingThread = this.threads.get(newComment.threadId);
       if (!existingThread) {
         return;
       }
-      this.#mutateThreadsDB(
-        (db) => db.upsert(applyUpsertComment(existingThread, newComment))
-      );
-      this.#updateInboxNotificationsCache((cache) => {
-        const existingNotification = Object.values(cache).find(
-          (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
-        );
-        if (!existingNotification) {
-          return cache;
-        }
-        return {
-          ...cache,
-          [existingNotification.id]: {
-            ...existingNotification,
-            notifiedAt: newComment.createdAt,
-            readAt: newComment.createdAt
-          }
-        };
-      });
+      this.threads.upsert(applyUpsertComment(existingThread, newComment));
+      this.notifications.updateAssociatedNotification(newComment);
     });
   }
-  editComment(threadId, optimisticUpdateId, editedComment) {
+  editComment(threadId, optimisticId, editedComment) {
     return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyUpsertComment(thread, editedComment)
     );
   }
-  deleteComment(threadId, optimisticUpdateId, commentId, deletedAt) {
+  deleteComment(threadId, optimisticId, commentId, deletedAt) {
     return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyDeleteComment(thread, commentId, deletedAt),
       deletedAt
     );
   }
-  updateThreadAndNotification(thread, inboxNotification) {
-    batch(() => {
-      this.#mutateThreadsDB((db) => db.upsertIfNewer(thread));
-      if (inboxNotification !== void 0) {
-        this.#updateInboxNotificationsCache((cache) => ({
-          ...cache,
-          [inboxNotification.id]: inboxNotification
-        }));
-      }
-    });
-  }
-  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
-    batch(() => {
-      this.#mutateThreadsDB(
-        (db) => applyThreadDeltaUpdates(db, { newThreads: threads, deletedThreads })
-      );
-      this.#updateInboxNotificationsCache(
-        (cache) => applyNotificationsUpdates(cache, {
-          newInboxNotifications: inboxNotifications,
-          deletedNotifications: deletedInboxNotifications
-        })
-      );
+  updateThreadifications(threads, notifications, deletedThreads = [], deletedNotifications = []) {
+    batch2(() => {
+      this.threads.applyDelta({ newThreads: threads, deletedThreads });
+      this.notifications.applyDelta(notifications, deletedNotifications);
     });
   }
   /**
    * Updates existing notification setting for a room with a new value,
    * replacing the corresponding optimistic update.
    */
-  updateRoomNotificationSettings_confirmOptimisticUpdate(roomId, optimisticUpdateId, settings) {
-    batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.#setNotificationSettings(roomId, settings);
+  updateRoomNotificationSettings(roomId, optimisticId, settings) {
+    batch2(() => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.roomNotificationSettings.update(roomId, settings);
     });
   }
-  addOptimisticUpdate(optimisticUpdate) {
-    const id = nanoid();
-    const newUpdate = { ...optimisticUpdate, id };
-    this.#updateOptimisticUpdatesCache((cache) => [...cache, newUpdate]);
-    return id;
-  }
-  removeOptimisticUpdate(optimisticUpdateId) {
-    this.#updateOptimisticUpdatesCache(
-      (cache) => cache.filter((ou) => ou.id !== optimisticUpdateId)
-    );
-  }
   async fetchNotificationsDeltaUpdate(signal) {
     const lastRequestedAt = this.#notificationsLastRequestedAt;
     if (lastRequestedAt === null) {
@@ -1104,7 +1181,7 @@ var UmbrellaStore = class {
     if (lastRequestedAt < result.requestedAt) {
       this.#notificationsLastRequestedAt = result.requestedAt;
     }
-    this.updateThreadsAndNotifications(
+    this.updateThreadifications(
       result.threads.updated,
       result.inboxNotifications.updated,
       result.threads.deleted,
@@ -1114,19 +1191,6 @@ var UmbrellaStore = class {
   waitUntilNotificationsLoaded() {
     return this.#notifications.waitUntilLoaded();
   }
-  #updatePermissionHints(newHints) {
-    this.permissionHintsByRoomId.set((prev) => {
-      const permissionsByRoom = { ...prev };
-      for (const [roomId, newPermissions] of Object.entries(newHints)) {
-        const existing = permissionsByRoom[roomId] ?? /* @__PURE__ */ new Set();
-        for (const permission of newPermissions) {
-          existing.add(permission);
-        }
-        permissionsByRoom[roomId] = existing;
-      }
-      return permissionsByRoom;
-    });
-  }
   waitUntilRoomThreadsLoaded(roomId, query) {
     const threadsFetcher = async (cursor) => {
       const result = await this.#client[kInternal].httpClient.getThreads({
@@ -1134,11 +1198,8 @@ var UmbrellaStore = class {
         cursor,
         query
       });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
-      this.#updatePermissionHints(result.permissionHints);
+      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);
@@ -1170,13 +1231,13 @@ var UmbrellaStore = class {
       since: lastRequestedAt,
       signal
     });
-    this.updateThreadsAndNotifications(
+    this.updateThreadifications(
       updates.threads.updated,
       updates.inboxNotifications.updated,
       updates.threads.deleted,
       updates.inboxNotifications.deleted
     );
-    this.#updatePermissionHints(updates.permissionHints);
+    this.permissionHints.update(updates.permissionHints);
     if (lastRequestedAt < updates.requestedAt) {
       this.#roomThreadsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
     }
@@ -1188,11 +1249,8 @@ var UmbrellaStore = class {
         cursor,
         query
       });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
-      this.#updatePermissionHints(result.permissionHints);
+      this.updateThreadifications(result.threads, result.inboxNotifications);
+      this.permissionHints.update(result.permissionHints);
       if (this.#userThreadsLastRequestedAt === null) {
         this.#userThreadsLastRequestedAt = result.requestedAt;
       }
@@ -1212,15 +1270,15 @@ var UmbrellaStore = class {
     this.#userThreads.set(queryKey, paginatedResource);
     return paginatedResource.waitUntilLoaded();
   }
-  // TODO(vincent+nimesh) We should really be going over all call sites, and replace this call
+  // XXX_vincent We should really be going over all call sites, and replace this call
   // with a more specific invalidation!
   invalidateEntireStore() {
-    batch(() => {
-      this.baseVersionsByRoomId.set((store) => ({ ...store }));
-      this.baseNotificationsById.set((store) => ({ ...store }));
-      this.optimisticUpdates.set((store) => [...store]);
-      this.permissionHintsByRoomId.set((store) => ({ ...store }));
-      this.baseSettingsByRoomId.set((store) => ({ ...store }));
+    batch2(() => {
+      this.historyVersions.invalidate();
+      this.notifications.invalidate();
+      this.optimisticUpdates.invalidate();
+      this.permissionHints.invalidate();
+      this.roomNotificationSettings.invalidate();
     });
   }
   async fetchUserThreadsDeltaUpdate(signal) {
@@ -1235,13 +1293,13 @@ var UmbrellaStore = class {
     if (lastRequestedAt < result.requestedAt) {
       this.#notificationsLastRequestedAt = result.requestedAt;
     }
-    this.updateThreadsAndNotifications(
+    this.updateThreadifications(
       result.threads.updated,
       result.inboxNotifications.updated,
       result.threads.deleted,
       result.inboxNotifications.deleted
     );
-    this.#updatePermissionHints(result.permissionHints);
+    this.permissionHints.update(result.permissionHints);
   }
   waitUntilRoomVersionsLoaded(roomId) {
     const queryKey = makeVersionsQueryKey(roomId);
@@ -1256,7 +1314,7 @@ var UmbrellaStore = class {
           );
         }
         const result = await room[kInternal].listTextVersions();
-        this.#updateRoomVersions(roomId, result.versions);
+        this.historyVersions.update(roomId, result.versions);
         const lastRequestedAt = this.#roomVersionsLastRequestedAtByRoom.get(roomId);
         if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
           this.#roomVersionsLastRequestedAtByRoom.set(
@@ -1290,7 +1348,7 @@ var UmbrellaStore = class {
       since: lastRequestedAt,
       signal
     });
-    this.#updateRoomVersions(roomId, updates.versions);
+    this.historyVersions.update(roomId, updates.versions);
     if (lastRequestedAt < updates.requestedAt) {
       this.#roomVersionsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
     }
@@ -1308,7 +1366,7 @@ var UmbrellaStore = class {
           );
         }
         const result = await room.getNotificationSettings();
-        this.#setNotificationSettings(roomId, result);
+        this.roomNotificationSettings.update(roomId, result);
       };
       resource = new SinglePageResource(notificationSettingsFetcher);
     }
@@ -1328,12 +1386,12 @@ var UmbrellaStore = class {
       `Room with id ${roomId} is not available on client`
     );
     const result = await room.getNotificationSettings({ signal });
-    this.#setNotificationSettings(roomId, result);
+    this.roomNotificationSettings.update(roomId, result);
   }
 };
-function applyOptimisticUpdates_forThreadifications(baseThreadsDB, rawNotificationsById, optimisticUpdates) {
+function applyOptimisticUpdates_forThreadifications(baseThreadsDB, notificationsLUT, optimisticUpdates) {
   const threadsDB = baseThreadsDB.clone();
-  let notificationsById = { ...rawNotificationsById };
+  let notificationsById = Object.fromEntries(notificationsLUT);
   for (const optimisticUpdate of optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "create-thread": {
@@ -1486,8 +1544,8 @@ function applyOptimisticUpdates_forThreadifications(baseThreadsDB, rawNotificati
     threadsDB
   };
 }
-function applyOptimisticUpdates_forSettings(baseSettingsByRoomId, optimisticUpdates) {
-  const settingsByRoomId = { ...baseSettingsByRoomId };
+function applyOptimisticUpdates_forSettings(settingsLUT, optimisticUpdates) {
+  const settingsByRoomId = Object.fromEntries(settingsLUT);
   for (const optimisticUpdate of optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "update-notification-settings": {
@@ -1504,32 +1562,6 @@ function applyOptimisticUpdates_forSettings(baseSettingsByRoomId, optimisticUpda
   }
   return settingsByRoomId;
 }
-function applyThreadDeltaUpdates(db, updates) {
-  updates.newThreads.forEach((thread) => db.upsertIfNewer(thread));
-  updates.deletedThreads.forEach(({ id, deletedAt }) => {
-    const existing = db.getEvenIfDeleted(id);
-    if (!existing) return;
-    db.delete(id, deletedAt);
-  });
-}
-function applyNotificationsUpdates(existingInboxNotifications, updates) {
-  const updatedInboxNotifications = { ...existingInboxNotifications };
-  updates.newInboxNotifications.forEach((notification) => {
-    const existingNotification = updatedInboxNotifications[notification.id];
-    if (existingNotification) {
-      const result = compareInboxNotifications(
-        existingNotification,
-        notification
-      );
-      if (result === 1) return;
-    }
-    updatedInboxNotifications[notification.id] = notification;
-  });
-  updates.deletedNotifications.forEach(
-    ({ id }) => delete updatedInboxNotifications[id]
-  );
-  return updatedInboxNotifications;
-}
 function compareInboxNotifications(inboxNotificationA, inboxNotificationB) {
   if (inboxNotificationA.notifiedAt > inboxNotificationB.notifiedAt) {
     return 1;
@@ -1920,21 +1952,21 @@ function useMarkInboxNotificationAsRead_withClient(client) {
     (inboxNotificationId) => {
       const { store } = getLiveblocksExtrasForClient(client);
       const readAt = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-inbox-notification-as-read",
         inboxNotificationId,
         readAt
       });
       client.markInboxNotificationAsRead(inboxNotificationId).then(
         () => {
-          store.updateInboxNotification(
+          store.markInboxNotificationRead(
             inboxNotificationId,
-            optimisticUpdateId,
-            (inboxNotification) => ({ ...inboxNotification, readAt })
+            readAt,
+            optimisticId
           );
         },
         () => {
-          store.removeOptimisticUpdate(optimisticUpdateId);
+          store.optimisticUpdates.remove(optimisticId);
         }
       );
     },
@@ -1945,19 +1977,16 @@ function useMarkAllInboxNotificationsAsRead_withClient(client) {
   return useCallback2(() => {
     const { store } = getLiveblocksExtrasForClient(client);
     const readAt = /* @__PURE__ */ new Date();
-    const optimisticUpdateId = store.addOptimisticUpdate({
+    const optimisticId = store.optimisticUpdates.add({
       type: "mark-all-inbox-notifications-as-read",
       readAt
     });
     client.markAllInboxNotificationsAsRead().then(
       () => {
-        store.updateAllInboxNotifications(
-          optimisticUpdateId,
-          (inboxNotification) => ({ ...inboxNotification, readAt })
-        );
+        store.markAllInboxNotificationsRead(optimisticId, readAt);
       },
       () => {
-        store.removeOptimisticUpdate(optimisticUpdateId);
+        store.optimisticUpdates.remove(optimisticId);
       }
     );
   }, [client]);
@@ -1967,20 +1996,17 @@ function useDeleteInboxNotification_withClient(client) {
     (inboxNotificationId) => {
       const { store } = getLiveblocksExtrasForClient(client);
       const deletedAt = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-inbox-notification",
         inboxNotificationId,
         deletedAt
       });
       client.deleteInboxNotification(inboxNotificationId).then(
         () => {
-          store.deleteInboxNotification(
-            inboxNotificationId,
-            optimisticUpdateId
-          );
+          store.deleteInboxNotification(inboxNotificationId, optimisticId);
         },
         () => {
-          store.removeOptimisticUpdate(optimisticUpdateId);
+          store.optimisticUpdates.remove(optimisticId);
         }
       );
     },
@@ -1991,16 +2017,16 @@ function useDeleteAllInboxNotifications_withClient(client) {
   return useCallback2(() => {
     const { store } = getLiveblocksExtrasForClient(client);
     const deletedAt = /* @__PURE__ */ new Date();
-    const optimisticUpdateId = store.addOptimisticUpdate({
+    const optimisticId = store.optimisticUpdates.add({
       type: "delete-all-inbox-notifications",
       deletedAt
     });
     client.deleteAllInboxNotifications().then(
       () => {
-        store.deleteAllInboxNotifications(optimisticUpdateId);
+        store.deleteAllInboxNotifications(optimisticId);
       },
       () => {
-        store.removeOptimisticUpdate(optimisticUpdateId);
+        store.optimisticUpdates.remove(optimisticId);
       }
     );
   }, [client]);
@@ -2594,8 +2620,8 @@ function getRoomExtrasForClient(client) {
 function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
   const commentsErrorEventSource = makeEventSource2();
-  function onMutationFailure(innerError, optimisticUpdateId, createPublicError) {
-    store.removeOptimisticUpdate(optimisticUpdateId);
+  function onMutationFailure(innerError, optimisticId, createPublicError) {
+    store.optimisticUpdates.remove(optimisticId);
     if (innerError instanceof HttpError2) {
       const error = handleApiError(innerError);
       commentsErrorEventSource.notify(createPublicError(error));
@@ -2851,7 +2877,7 @@ function RoomProviderInner(props) {
         store.deleteThread(message.threadId, null);
         return;
       }
-      const { thread, inboxNotification } = info;
+      const { thread, inboxNotification: maybeNotification } = info;
       const existingThread = store.get1_threads().threadsDB.getEvenIfDeleted(message.threadId);
       switch (message.type) {
         case ServerMsgCode.COMMENT_EDITED:
@@ -2861,10 +2887,16 @@ function RoomProviderInner(props) {
         case ServerMsgCode.COMMENT_REACTION_REMOVED:
         case ServerMsgCode.COMMENT_DELETED:
           if (!existingThread) break;
-          store.updateThreadAndNotification(thread, inboxNotification);
+          store.updateThreadifications(
+            [thread],
+            maybeNotification ? [maybeNotification] : []
+          );
           break;
         case ServerMsgCode.COMMENT_CREATED:
-          store.updateThreadAndNotification(thread, inboxNotification);
+          store.updateThreadifications(
+            [thread],
+            maybeNotification ? [maybeNotification] : []
+          );
           break;
         default:
           break;
@@ -3301,7 +3333,7 @@ function useCreateRoomThread(roomId) {
         resolved: false
       };
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "create-thread",
         thread: newThread,
         roomId
@@ -3316,11 +3348,11 @@ function useCreateRoomThread(roomId) {
         attachmentIds
       }).then(
         (thread) => {
-          store.createThread(optimisticUpdateId, thread);
+          store.createThread(optimisticId, thread);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new CreateThreadError(err2, {
             roomId,
             threadId,
@@ -3348,7 +3380,7 @@ function useDeleteRoomThread(roomId) {
       if (existing?.comments?.[0]?.userId !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-thread",
         roomId,
         threadId,
@@ -3356,11 +3388,11 @@ function useDeleteRoomThread(roomId) {
       });
       client[kInternal3].httpClient.deleteThread({ roomId, threadId }).then(
         () => {
-          store.deleteThread(threadId, optimisticUpdateId);
+          store.deleteThread(threadId, optimisticId);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new DeleteThreadError(err2, { roomId, threadId })
         )
       );
@@ -3382,7 +3414,7 @@ function useEditRoomThreadMetadata(roomId) {
       const metadata = options.metadata;
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "edit-thread-metadata",
         metadata,
         threadId,
@@ -3391,16 +3423,11 @@ function useEditRoomThreadMetadata(roomId) {
       client[kInternal3].httpClient.editThreadMetadata({ roomId, threadId, metadata }).then(
         (metadata2) => (
           // Replace the optimistic update by the real thing
-          store.patchThread(
-            threadId,
-            optimisticUpdateId,
-            { metadata: metadata2 },
-            updatedAt
-          )
+          store.patchThread(threadId, optimisticId, { metadata: metadata2 }, updatedAt)
         ),
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new EditThreadMetadataError(error, {
             roomId,
             threadId,
@@ -3433,18 +3460,18 @@ function useCreateRoomComment(roomId) {
         attachments: attachments ?? []
       };
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "create-comment",
         comment
       });
       const attachmentIds = attachments?.map((attachment) => attachment.id);
       client[kInternal3].httpClient.createComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (newComment) => {
-          store.createComment(newComment, optimisticUpdateId);
+          store.createComment(newComment, optimisticId);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new CreateCommentError(err2, {
             roomId,
             threadId,
@@ -3483,7 +3510,7 @@ function useEditRoomComment(roomId) {
         );
         return;
       }
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "edit-comment",
         comment: {
           ...comment,
@@ -3495,11 +3522,11 @@ function useEditRoomComment(roomId) {
       const attachmentIds = attachments?.map((attachment) => attachment.id);
       client[kInternal3].httpClient.editComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (editedComment) => {
-          store.editComment(threadId, optimisticUpdateId, editedComment);
+          store.editComment(threadId, optimisticId, editedComment);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new EditCommentError(error, {
             roomId,
             threadId,
@@ -3521,7 +3548,7 @@ function useDeleteRoomComment(roomId) {
     ({ threadId, commentId }) => {
       const deletedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-comment",
         threadId,
         commentId,
@@ -3530,16 +3557,11 @@ function useDeleteRoomComment(roomId) {
       });
       client[kInternal3].httpClient.deleteComment({ roomId, threadId, commentId }).then(
         () => {
-          store.deleteComment(
-            threadId,
-            optimisticUpdateId,
-            commentId,
-            deletedAt
-          );
+          store.deleteComment(threadId, optimisticId, commentId, deletedAt);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new DeleteCommentError(error, {
             roomId,
             threadId,
@@ -3561,7 +3583,7 @@ function useAddRoomCommentReaction(roomId) {
       const createdAt = /* @__PURE__ */ new Date();
       const userId = getCurrentUserId(client);
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "add-reaction",
         threadId,
         commentId,
@@ -3575,7 +3597,7 @@ function useAddRoomCommentReaction(roomId) {
         (addedReaction) => {
           store.addReaction(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             commentId,
             addedReaction,
             createdAt
@@ -3583,7 +3605,7 @@ function useAddRoomCommentReaction(roomId) {
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new AddReactionError(error, {
             roomId,
             threadId,
@@ -3606,7 +3628,7 @@ function useRemoveRoomCommentReaction(roomId) {
       const userId = getCurrentUserId(client);
       const removedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "remove-reaction",
         threadId,
         commentId,
@@ -3618,7 +3640,7 @@ function useRemoveRoomCommentReaction(roomId) {
         () => {
           store.removeReaction(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             commentId,
             emoji,
             userId,
@@ -3627,7 +3649,7 @@ function useRemoveRoomCommentReaction(roomId) {
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new RemoveReactionError(error, {
             roomId,
             threadId,
@@ -3655,7 +3677,7 @@ function useMarkRoomThreadAsRead(roomId) {
       );
       if (!inboxNotification) return;
       const now = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-inbox-notification-as-read",
         inboxNotificationId: inboxNotification.id,
         readAt: now
@@ -3665,16 +3687,16 @@ function useMarkRoomThreadAsRead(roomId) {
         inboxNotificationId: inboxNotification.id
       }).then(
         () => {
-          store.updateInboxNotification(
+          store.markInboxNotificationRead(
             inboxNotification.id,
-            optimisticUpdateId,
-            (inboxNotification2) => ({ ...inboxNotification2, readAt: now })
+            now,
+            optimisticId
           );
         },
         (err) => {
           onMutationFailure(
             err,
-            optimisticUpdateId,
+            optimisticId,
             (error) => new MarkInboxNotificationAsReadError(error, {
               inboxNotificationId: inboxNotification.id
             })
@@ -3695,7 +3717,7 @@ function useMarkRoomThreadAsResolved(roomId) {
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-thread-as-resolved",
         threadId,
         updatedAt
@@ -3704,14 +3726,14 @@ function useMarkRoomThreadAsResolved(roomId) {
         () => {
           store.patchThread(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             { resolved: true },
             updatedAt
           );
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new MarkThreadAsResolvedError(error, {
             roomId,
             threadId
@@ -3731,7 +3753,7 @@ function useMarkRoomThreadAsUnresolved(roomId) {
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-thread-as-unresolved",
         threadId,
         updatedAt
@@ -3740,14 +3762,14 @@ function useMarkRoomThreadAsUnresolved(roomId) {
         () => {
           store.patchThread(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             { resolved: false },
             updatedAt
           );
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new MarkThreadAsUnresolvedError(error, {
             roomId,
             threadId
@@ -3914,22 +3936,18 @@ function useUpdateRoomNotificationSettings() {
   return useCallback3(
     (settings) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "update-notification-settings",
         roomId: room.id,
         settings
       });
       room.updateNotificationSettings(settings).then(
         (settings2) => {
-          store.updateRoomNotificationSettings_confirmOptimisticUpdate(
-            room.id,
-            optimisticUpdateId,
-            settings2
-          );
+          store.updateRoomNotificationSettings(room.id, optimisticId, settings2);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new UpdateNotificationSettingsError(error, {
             roomId: room.id
           })
@@ -4072,7 +4090,7 @@ function useRoomPermissions(roomId) {
   const client = useClient();
   const store = getRoomExtrasForClient(client).store;
   return useSignal(
-    store.permissionHintsByRoomId,
+    store.permissionHints.signal,
     (hints) => hints[roomId] ?? /* @__PURE__ */ new Set()
   );
 }
@@ -4223,4 +4241,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-UJLD6FYC.mjs.map
+//# sourceMappingURL=chunk-NZZCQLBR.mjs.map