@liveblocks/react 2.13.3-emails1 → 2.14.0-lexical1

package/dist/{chunk-X4DDEZYL.js → chunk-N33NEN5R.js}

@@ -132,6 +132,8 @@ var use = (
 
 
 
+
+
 // src/lib/autobind.ts
 function autobind(self) {
   const seen = /* @__PURE__ */ new Set();
@@ -202,36 +204,35 @@ function sanitizeThread(thread) {
   return thread;
 }
 var ThreadDB = class _ThreadDB {
-  // The version is auto-incremented on every mutation and can be used as a reliable indicator to tell if the contents of the thread pool has changed
+  #byId;
+  #asc;
+  #desc;
+  // This signal will be notified on every mutation
+  
   constructor() {
-    this._asc = _core.SortedList.from([], (t1, t2) => {
+    this.#asc = _core.SortedList.from([], (t1, t2) => {
       const d1 = t1.createdAt;
       const d2 = t2.createdAt;
       return d1 < d2 ? true : d1 === d2 ? t1.id < t2.id : false;
     });
-    this._desc = _core.SortedList.from([], (t1, t2) => {
+    this.#desc = _core.SortedList.from([], (t1, t2) => {
       const d2 = t2.updatedAt;
       const d1 = t1.updatedAt;
       return d2 < d1 ? true : d2 === d1 ? t2.id < t1.id : false;
     });
-    this._byId = /* @__PURE__ */ new Map();
-    this._version = 0;
+    this.#byId = /* @__PURE__ */ new Map();
+    this.signal = new (0, _core.MutableSignal)(this);
   }
   //
   // Public APIs
   //
   clone() {
     const newPool = new _ThreadDB();
-    newPool._byId = new Map(this._byId);
-    newPool._asc = this._asc.clone();
-    newPool._desc = this._desc.clone();
-    newPool._version = this._version;
+    newPool.#byId = new Map(this.#byId);
+    newPool.#asc = this.#asc.clone();
+    newPool.#desc = this.#desc.clone();
     return newPool;
   }
-  /** Gets the transaction count for this DB. Increments any time the DB is modified. */
-  get version() {
-    return this._version;
-  }
   /** Returns an existing thread by ID. Will never return a deleted thread. */
   get(threadId) {
     const thread = this.getEvenIfDeleted(threadId);
@@ -239,24 +240,26 @@ var ThreadDB = class _ThreadDB {
   }
   /** Returns the (possibly deleted) thread by ID. */
   getEvenIfDeleted(threadId) {
-    return this._byId.get(threadId);
+    return this.#byId.get(threadId);
   }
   /** Adds or updates a thread in the DB. If the newly given thread is a deleted one, it will get deleted. */
   upsert(thread) {
-    thread = sanitizeThread(thread);
-    const id = thread.id;
-    const toRemove = this._byId.get(id);
-    if (toRemove) {
-      if (toRemove.deletedAt) return;
-      this._asc.remove(toRemove);
-      this._desc.remove(toRemove);
-    }
-    if (!thread.deletedAt) {
-      this._asc.add(thread);
-      this._desc.add(thread);
-    }
-    this._byId.set(id, thread);
-    this.touch();
+    this.signal.mutate(() => {
+      thread = sanitizeThread(thread);
+      const id = thread.id;
+      const toRemove = this.#byId.get(id);
+      if (toRemove) {
+        if (toRemove.deletedAt) return false;
+        this.#asc.remove(toRemove);
+        this.#desc.remove(toRemove);
+      }
+      if (!thread.deletedAt) {
+        this.#asc.add(thread);
+        this.#desc.add(thread);
+      }
+      this.#byId.set(id, thread);
+      return true;
+    });
   }
   /** Like .upsert(), except it won't update if a thread by this ID already exists. */
   // TODO Consider renaming this to just .upsert(). I'm not sure if we really
@@ -272,7 +275,7 @@ var ThreadDB = class _ThreadDB {
    * queries, but it can still be accessed via `.getEvenIfDeleted()`.
    */
   delete(threadId, deletedAt) {
-    const existing = this._byId.get(threadId);
+    const existing = this.#byId.get(threadId);
     if (existing && !existing.deletedAt) {
       this.upsert({ ...existing, deletedAt, updatedAt: deletedAt });
     }
@@ -289,7 +292,7 @@ var ThreadDB = class _ThreadDB {
    * Will never return deleted threads in the result.
    */
   findMany(roomId, query, direction) {
-    const index = direction === "desc" ? this._desc : this._asc;
+    const index = direction === "desc" ? this.#desc : this.#asc;
     const crit = [];
     if (roomId !== void 0) {
       crit.push((t) => t.roomId === roomId);
@@ -297,12 +300,6 @@ var ThreadDB = class _ThreadDB {
     crit.push(makeThreadsFilter(query));
     return Array.from(index.filter((t) => crit.every((pred) => pred(t))));
   }
-  //
-  // Private APIs
-  //
-  touch() {
-    ++this._version;
-  }
 };
 
 // src/umbrella-store.ts
@@ -339,62 +336,67 @@ function usify(promise) {
 var noop2 = Promise.resolve();
 var ASYNC_LOADING = Object.freeze({ isLoading: true });
 var PaginatedResource = class {
+  
+  #eventSource;
+  #fetchPage;
+  #paginationState;
+  // Should be null while in loading or error state!
+  #pendingFetchMore;
   constructor(fetchPage) {
-    this._cachedPromise = null;
-    this._paginationState = null;
-    this._fetchPage = fetchPage;
-    this._eventSource = _core.makeEventSource.call(void 0, );
-    this._pendingFetchMore = null;
-    this.observable = this._eventSource.observable;
+    this.#paginationState = null;
+    this.#fetchPage = fetchPage;
+    this.#eventSource = _core.makeEventSource.call(void 0, );
+    this.#pendingFetchMore = null;
+    this.observable = this.#eventSource.observable;
     autobind(this);
   }
-  patchPaginationState(patch) {
-    const state = this._paginationState;
+  #patchPaginationState(patch) {
+    const state = this.#paginationState;
     if (state === null) return;
-    this._paginationState = { ...state, ...patch };
-    this._eventSource.notify();
+    this.#paginationState = { ...state, ...patch };
+    this.#eventSource.notify();
   }
-  async _fetchMore() {
-    const state = this._paginationState;
+  async #fetchMore() {
+    const state = this.#paginationState;
     if (!_optionalChain([state, 'optionalAccess', _3 => _3.cursor])) {
       return;
     }
-    this.patchPaginationState({ isFetchingMore: true });
+    this.#patchPaginationState({ isFetchingMore: true });
     try {
-      const nextCursor = await this._fetchPage(state.cursor);
-      this.patchPaginationState({
+      const nextCursor = await this.#fetchPage(state.cursor);
+      this.#patchPaginationState({
         cursor: nextCursor,
         fetchMoreError: void 0,
         isFetchingMore: false
       });
     } catch (err) {
-      this.patchPaginationState({
+      this.#patchPaginationState({
         isFetchingMore: false,
         fetchMoreError: err
       });
     }
   }
   fetchMore() {
-    const state = this._paginationState;
+    const state = this.#paginationState;
     if (_optionalChain([state, 'optionalAccess', _4 => _4.cursor]) === null) {
       return noop2;
     }
-    if (!this._pendingFetchMore) {
-      this._pendingFetchMore = this._fetchMore().finally(() => {
-        this._pendingFetchMore = null;
+    if (!this.#pendingFetchMore) {
+      this.#pendingFetchMore = this.#fetchMore().finally(() => {
+        this.#pendingFetchMore = null;
       });
     }
-    return this._pendingFetchMore;
+    return this.#pendingFetchMore;
   }
   get() {
-    const usable = this._cachedPromise;
+    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;
+    const state = this.#paginationState;
     return {
       isLoading: false,
       data: {
@@ -405,12 +407,13 @@ var PaginatedResource = class {
       }
     };
   }
+  #cachedPromise = null;
   waitUntilLoaded() {
-    if (this._cachedPromise) {
-      return this._cachedPromise;
+    if (this.#cachedPromise) {
+      return this.#cachedPromise;
     }
     const initialFetcher = _core.autoRetry.call(void 0, 
-      () => this._fetchPage(
+      () => this.#fetchPage(
         /* cursor */
         void 0
       ),
@@ -419,7 +422,7 @@ var PaginatedResource = class {
     );
     const promise = usify(
       initialFetcher.then((cursor) => {
-        this._paginationState = {
+        this.#paginationState = {
           cursor,
           isFetchingMore: false,
           fetchMoreError: void 0
@@ -427,29 +430,31 @@ var PaginatedResource = class {
       })
     );
     promise.then(
-      () => this._eventSource.notify(),
+      () => this.#eventSource.notify(),
       () => {
-        this._eventSource.notify();
+        this.#eventSource.notify();
         setTimeout(() => {
-          this._cachedPromise = null;
-          this._eventSource.notify();
+          this.#cachedPromise = null;
+          this.#eventSource.notify();
         }, 5e3);
       }
     );
-    this._cachedPromise = promise;
+    this.#cachedPromise = promise;
     return promise;
   }
 };
 var SinglePageResource = class {
+  
+  #eventSource;
+  #fetchPage;
   constructor(fetchPage) {
-    this._cachedPromise = null;
-    this._fetchPage = fetchPage;
-    this._eventSource = _core.makeEventSource.call(void 0, );
-    this.observable = this._eventSource.observable;
+    this.#fetchPage = fetchPage;
+    this.#eventSource = _core.makeEventSource.call(void 0, );
+    this.observable = this.#eventSource.observable;
     autobind(this);
   }
   get() {
-    const usable = this._cachedPromise;
+    const usable = this.#cachedPromise;
     if (usable === null || usable.status === "pending") {
       return ASYNC_LOADING;
     }
@@ -461,95 +466,187 @@ var SinglePageResource = class {
       data: void 0
     };
   }
+  #cachedPromise = null;
   waitUntilLoaded() {
-    if (this._cachedPromise) {
-      return this._cachedPromise;
+    if (this.#cachedPromise) {
+      return this.#cachedPromise;
     }
     const initialFetcher = _core.autoRetry.call(void 0, 
-      () => this._fetchPage(),
+      () => this.#fetchPage(),
       5,
       [5e3, 5e3, 1e4, 15e3]
     );
     const promise = usify(initialFetcher);
     promise.then(
-      () => this._eventSource.notify(),
+      () => this.#eventSource.notify(),
       () => {
-        this._eventSource.notify();
+        this.#eventSource.notify();
         setTimeout(() => {
-          this._cachedPromise = null;
-          this._eventSource.notify();
+          this.#cachedPromise = null;
+          this.#eventSource.notify();
         }, 5e3);
       }
     );
-    this._cachedPromise = promise;
+    this.#cachedPromise = promise;
     return promise;
   }
 };
 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
+  // clean "external state" is recomputed.
+  //
+  //   Mutate inputs...                                             ...observe clean/consistent output!
+  //
+  //            .-> Base ThreadDB ---------+                 +----> Clean threads by ID       (Part 1)
+  //           /                           |                 |
+  //   mutate ----> Base Notifications --+ |                 | +--> Clean notifications       (Part 1)
+  //          \                          | |                 | |    & notifications by ID
+  //         | \                         | |      Apply      | |
+  //         |   `-> OptimisticUpdates --+--+--> Optimistic --+-+--> Notification Settings    (Part 2)
+  //          \                          |        Updates       |
+  //           `------- etc etc ---------+                      +--> History Versions         (Part 3)
+  //                       ^
+  //                       |
+  //                       |                        ^                  ^
+  //                    Signal                      |                  |
+  //                      or                   DerivedSignal      DerivedSignals
+  //                  MutableSignal
+  //
+  //
+  // Input signals.
+  // (Can be mutated directly.)
+  //
+  
+  // Exposes its signal under `.signal` prop
+  
+  
+  
+  
+  
+  //
+  // Output signals.
+  // (Readonly, clean, consistent. With optimistic updates applied.)
+  //
+  // Note that the output of threadifications signal is the same as the ones for
+  // 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.
+  //
+  
+  // 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;
+  // 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._prevVersion = -1;
-    this._prevState = null;
-    this._stateCached = null;
-    // Notifications
-    this._notificationsLastRequestedAt = null;
-    // Room Threads
-    this._roomThreadsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
-    this._roomThreads = /* @__PURE__ */ new Map();
-    // User Threads
-    this._userThreadsLastRequestedAt = null;
-    this._userThreads = /* @__PURE__ */ new Map();
-    // Room versions
-    this._roomVersions = /* @__PURE__ */ new Map();
-    this._roomVersionsLastRequestedAtByRoom = /* @__PURE__ */ new Map();
-    // Room notification settings
-    this._roomNotificationSettings = /* @__PURE__ */ new Map();
-    this._client = client[_core.kInternal].as();
-    this._syncSource = this._client[_core.kInternal].createSyncSource();
+    this.#client = client[_core.kInternal].as();
+    this.#syncSource = this.#client[_core.kInternal].createSyncSource();
     const inboxFetcher = async (cursor) => {
-      const result = await this._client.getInboxNotifications({ cursor });
+      const result = await this.#client.getInboxNotifications({ cursor });
       this.updateThreadsAndNotifications(
         result.threads,
         result.inboxNotifications
       );
-      if (this._notificationsLastRequestedAt === null) {
-        this._notificationsLastRequestedAt = result.requestedAt;
+      if (this.#notificationsLastRequestedAt === null) {
+        this.#notificationsLastRequestedAt = result.requestedAt;
       }
       const nextCursor = result.nextCursor;
       return nextCursor;
     };
-    this._notifications = new PaginatedResource(inboxFetcher);
-    this._notifications.observable.subscribe(
+    this.#notifications = new PaginatedResource(inboxFetcher);
+    this.#notifications.observable.subscribe(
       () => (
         // Note that the store itself does not change, but it's only vehicle at
         // the moment to trigger a re-render, so we'll do a no-op update here.
-        this._store.set((store) => ({ ...store }))
+        this.invalidateEntireStore()
+      )
+    );
+    this.baseThreadsDB = new ThreadDB();
+    this.optimisticUpdates = new (0, _core.Signal)([]);
+    this.baseVersionsByRoomId = new (0, _core.Signal)({});
+    this.baseNotificationsById = new (0, _core.Signal)({});
+    this.baseSettingsByRoomId = new (0, _core.Signal)({});
+    this.permissionHintsByRoomId = new (0, _core.Signal)({});
+    const threadifications = _core.DerivedSignal.from(
+      this.baseThreadsDB.signal,
+      this.baseNotificationsById,
+      this.optimisticUpdates,
+      (ts, ns, updates) => applyOptimisticUpdates_forThreadifications(ts, ns, updates)
+    );
+    const threads = _core.DerivedSignal.from(threadifications, (s) => ({
+      threadsDB: s.threadsDB
+    }));
+    const notifications = _core.DerivedSignal.from(threadifications, (s) => ({
+      sortedNotifications: s.sortedNotifications,
+      notificationsById: s.notificationsById
+    }));
+    const settingsByRoomId = _core.DerivedSignal.from(
+      this.baseSettingsByRoomId,
+      this.optimisticUpdates,
+      (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
+    );
+    const versionsByRoomId = _core.DerivedSignal.from(
+      this.baseVersionsByRoomId,
+      (hv) => hv
+    );
+    this.outputs = {
+      threadifications,
+      threads,
+      notifications,
+      settingsByRoomId,
+      versionsByRoomId
+    };
+    this.optimisticUpdates.subscribe(
+      () => this.#syncSource.setSyncStatus(
+        this.optimisticUpdates.get().length > 0 ? "synchronizing" : "synchronized"
       )
     );
-    this._rawThreadsDB = new ThreadDB();
-    this._store = _core.createStore.call(void 0, {
-      optimisticUpdates: [],
-      permissionsByRoom: {},
-      notificationsById: {},
-      settingsByRoomId: {},
-      versionsByRoomId: {}
-    });
     autobind(this);
   }
-  get() {
-    const rawState = this._store.get();
-    if (this._prevVersion !== this._rawThreadsDB.version || // Note: Version check is only needed temporarily, until we can get rid of the Zustand-like update model
-    this._prevState !== rawState || this._stateCached === null) {
-      this._stateCached = internalToExternalState(rawState, this._rawThreadsDB);
-      this._prevState = rawState;
-      this._prevVersion = this._rawThreadsDB.version;
-    }
-    return this._stateCached;
+  get1_both() {
+    return this.outputs.threadifications.get();
+  }
+  subscribe1_both(callback) {
+    return this.outputs.threadifications.subscribe(callback);
   }
-  batch(callback) {
-    return this._store.batch(callback);
+  get1_threads() {
+    return this.outputs.threads.get();
   }
-  getFullState() {
-    return this.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,
@@ -558,7 +655,7 @@ var UmbrellaStore = class {
    */
   getRoomThreadsLoadingState(roomId, query) {
     const queryKey = makeRoomThreadsQueryKey(roomId, query);
-    const paginatedResource = this._roomThreads.get(queryKey);
+    const paginatedResource = this.#roomThreads.get(queryKey);
     if (paginatedResource === void 0) {
       return ASYNC_LOADING;
     }
@@ -566,7 +663,7 @@ var UmbrellaStore = class {
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
     }
-    const threads = this.getFullState().threadsDB.findMany(
+    const threads = this.get1_threads().threadsDB.findMany(
       roomId,
       _nullishCoalesce(query, () => ( {})),
       "asc"
@@ -583,7 +680,7 @@ var UmbrellaStore = class {
   }
   getUserThreadsLoadingState(query) {
     const queryKey = makeUserThreadsQueryKey(query);
-    const paginatedResource = this._userThreads.get(queryKey);
+    const paginatedResource = this.#userThreads.get(queryKey);
     if (paginatedResource === void 0) {
       return ASYNC_LOADING;
     }
@@ -591,7 +688,7 @@ var UmbrellaStore = class {
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
     }
-    const threads = this.getFullState().threadsDB.findMany(
+    const threads = this.get1_threads().threadsDB.findMany(
       void 0,
       // Do _not_ filter by roomId
       _nullishCoalesce(query, () => ( {})),
@@ -609,14 +706,14 @@ var UmbrellaStore = class {
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
   getInboxNotificationsLoadingState() {
-    const asyncResult = this._notifications.get();
+    const asyncResult = this.#notifications.get();
     if (asyncResult.isLoading || asyncResult.error) {
       return asyncResult;
     }
     const page = asyncResult.data;
     return {
       isLoading: false,
-      inboxNotifications: this.getFullState().cleanedNotifications,
+      inboxNotifications: this.get1_notifications().sortedNotifications,
       hasFetchedAll: page.hasFetchedAll,
       isFetchingMore: page.isFetchingMore,
       fetchMoreError: page.fetchMoreError,
@@ -624,9 +721,10 @@ 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!
   getNotificationSettingsLoadingState(roomId) {
     const queryKey = makeNotificationSettingsQueryKey(roomId);
-    const resource = this._roomNotificationSettings.get(queryKey);
+    const resource = this.#roomNotificationSettings.get(queryKey);
     if (resource === void 0) {
       return ASYNC_LOADING;
     }
@@ -636,12 +734,12 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      settings: _core.nn.call(void 0, this.get().settingsByRoomId[roomId])
+      settings: _core.nn.call(void 0, this.get2()[roomId])
     };
   }
   getRoomVersionsLoadingState(roomId) {
     const queryKey = makeVersionsQueryKey(roomId);
-    const resource = this._roomVersions.get(queryKey);
+    const resource = this.#roomVersions.get(queryKey);
     if (resource === void 0) {
       return ASYNC_LOADING;
     }
@@ -651,70 +749,53 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      versions: Object.values(_nullishCoalesce(this.get().versionsByRoomId[roomId], () => ( {})))
+      versions: Object.values(_nullishCoalesce(this.get3()[roomId], () => ( {})))
     };
   }
-  subscribe(callback) {
-    return this._store.subscribe(callback);
-  }
-  _getPermissions(roomId) {
-    return this._store.get().permissionsByRoom[roomId];
-  }
   // Direct low-level cache mutations ------------------------------------------------- {{{
-  mutateThreadsDB(mutate) {
-    const db = this._rawThreadsDB;
-    const old = db.version;
-    mutate(db);
-    if (old !== db.version) {
-      this._store.set((state) => ({ ...state }));
-    }
-  }
-  updateInboxNotificationsCache(mapFn) {
-    this._store.set((state) => {
-      const inboxNotifications = mapFn(state.notificationsById);
-      return inboxNotifications !== state.notificationsById ? { ...state, notificationsById: inboxNotifications } : state;
+  #mutateThreadsDB(mutate) {
+    _core.batch.call(void 0, () => {
+      mutate(this.baseThreadsDB);
     });
   }
-  setNotificationSettings(roomId, settings) {
-    this._store.set((state) => ({
+  #updateInboxNotificationsCache(mapFn) {
+    this.baseNotificationsById.set((prev) => mapFn(prev));
+  }
+  #setNotificationSettings(roomId, settings) {
+    this.baseSettingsByRoomId.set((state) => ({
       ...state,
-      settingsByRoomId: {
-        ...state.settingsByRoomId,
-        [roomId]: settings
-      }
+      [roomId]: settings
     }));
   }
-  updateRoomVersions(roomId, versions) {
-    this._store.set((state) => {
-      const versionsById = Object.fromEntries(
-        versions.map((version2) => [version2.id, version2])
-      );
+  #updateRoomVersions(roomId, versions) {
+    this.baseVersionsByRoomId.set((prev) => {
+      const newVersions = { ...prev[roomId] };
+      for (const version2 of versions) {
+        newVersions[version2.id] = version2;
+      }
       return {
-        ...state,
-        versionsByRoomId: {
-          ...state.versionsByRoomId,
-          [roomId]: {
-            // Merge with existing versions for the room, or start with an empty object
-            ..._nullishCoalesce(state.versionsByRoomId[roomId], () => ( {})),
-            ...versionsById
-          }
-        }
+        ...prev,
+        [roomId]: newVersions
       };
     });
   }
-  updateOptimisticUpdatesCache(mapFn) {
-    this._store.set((state) => {
-      const optimisticUpdates = mapFn(state.optimisticUpdates);
-      this._syncSource.setSyncStatus(
-        optimisticUpdates.length > 0 ? "synchronizing" : "synchronized"
-      );
-      return { ...state, optimisticUpdates };
-    });
+  #updateOptimisticUpdatesCache(mapFn) {
+    this.optimisticUpdates.set(mapFn);
   }
   // ---------------------------------------------------------------------------------- }}}
   /** @internal - Only call this method from unit tests. */
-  force_set(callback) {
-    return this._store.set(callback);
+  force_set_versions(callback) {
+    _core.batch.call(void 0, () => {
+      this.baseVersionsByRoomId.set(callback);
+      this.invalidateEntireStore();
+    });
+  }
+  /** @internal - Only call this method from unit tests. */
+  force_set_notifications(callback) {
+    _core.batch.call(void 0, () => {
+      this.baseNotificationsById.set(callback);
+      this.invalidateEntireStore();
+    });
   }
   /**
    * Updates an existing inbox notification with a new value, replacing the
@@ -724,18 +805,17 @@ var UmbrellaStore = class {
    * the cache.
    */
   updateInboxNotification(inboxNotificationId, optimisticUpdateId, callback) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => {
+      this.#updateInboxNotificationsCache((cache) => {
         const existing = cache[inboxNotificationId];
         if (!existing) {
           return cache;
         }
-        const inboxNotifications = {
+        return {
           ...cache,
           [inboxNotificationId]: callback(existing)
         };
-        return inboxNotifications;
       });
     });
   }
@@ -744,9 +824,9 @@ var UmbrellaStore = class {
    * them, replacing the corresponding optimistic update.
    */
   updateAllInboxNotifications(optimisticUpdateId, mapFn) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => _core.mapValues.call(void 0, cache, mapFn));
+      this.#updateInboxNotificationsCache((cache) => _core.mapValues.call(void 0, cache, mapFn));
     });
   }
   /**
@@ -754,9 +834,9 @@ var UmbrellaStore = class {
    * optimistic update.
    */
   deleteInboxNotification(inboxNotificationId, optimisticUpdateId) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => {
+      this.#updateInboxNotificationsCache((cache) => {
         const { [inboxNotificationId]: removed, ...newCache } = cache;
         return removed === void 0 ? cache : newCache;
       });
@@ -767,18 +847,18 @@ var UmbrellaStore = class {
    * update.
    */
   deleteAllInboxNotifications(optimisticUpdateId) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache(() => ({}));
+      this.#updateInboxNotificationsCache(() => ({}));
     });
   }
   /**
    * Creates an new thread, replacing the corresponding optimistic update.
    */
   createThread(optimisticUpdateId, thread) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.mutateThreadsDB((db) => db.upsert(thread));
+      this.#mutateThreadsDB((db) => db.upsert(thread));
     });
   }
   /**
@@ -791,12 +871,12 @@ var UmbrellaStore = class {
    * - The thread ID in the cache was updated more recently than the optimistic
    *   update's timestamp (if given)
    */
-  updateThread(threadId, optimisticUpdateId, callback, updatedAt) {
-    this._store.batch(() => {
+  #updateThread(threadId, optimisticUpdateId, callback, updatedAt) {
+    _core.batch.call(void 0, () => {
       if (optimisticUpdateId !== null) {
         this.removeOptimisticUpdate(optimisticUpdateId);
       }
-      this.mutateThreadsDB((db) => {
+      this.#mutateThreadsDB((db) => {
         const existing = db.get(threadId);
         if (!existing) return;
         if (!!updatedAt && existing.updatedAt > updatedAt) return;
@@ -805,7 +885,7 @@ var UmbrellaStore = class {
     });
   }
   patchThread(threadId, optimisticUpdateId, patch, updatedAt) {
-    return this.updateThread(
+    return this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => ({ ...thread, ..._core.compactObject.call(void 0, patch) }),
@@ -813,7 +893,7 @@ var UmbrellaStore = class {
     );
   }
   addReaction(threadId, optimisticUpdateId, commentId, reaction, createdAt) {
-    this.updateThread(
+    this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => applyAddReaction(thread, commentId, reaction),
@@ -821,7 +901,7 @@ var UmbrellaStore = class {
     );
   }
   removeReaction(threadId, optimisticUpdateId, commentId, emoji, userId, removedAt) {
-    this.updateThread(
+    this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => applyRemoveReaction(thread, commentId, emoji, userId, removedAt),
@@ -837,7 +917,7 @@ var UmbrellaStore = class {
    * - The thread ID was already deleted from the cache
    */
   deleteThread(threadId, optimisticUpdateId) {
-    return this.updateThread(
+    return this.#updateThread(
       threadId,
       optimisticUpdateId,
       // A deletion is actually an update of the deletedAt property internally
@@ -849,16 +929,16 @@ var UmbrellaStore = class {
    * updated correctly, replacing the corresponding optimistic update.
    */
   createComment(newComment, optimisticUpdateId) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      const existingThread = this._rawThreadsDB.get(newComment.threadId);
+      const existingThread = this.baseThreadsDB.get(newComment.threadId);
       if (!existingThread) {
         return;
       }
-      this.mutateThreadsDB(
+      this.#mutateThreadsDB(
         (db) => db.upsert(applyUpsertComment(existingThread, newComment))
       );
-      this.updateInboxNotificationsCache((cache) => {
+      this.#updateInboxNotificationsCache((cache) => {
         const existingNotification = Object.values(cache).find(
           (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
         );
@@ -877,14 +957,14 @@ var UmbrellaStore = class {
     });
   }
   editComment(threadId, optimisticUpdateId, editedComment) {
-    return this.updateThread(
+    return this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => applyUpsertComment(thread, editedComment)
     );
   }
   deleteComment(threadId, optimisticUpdateId, commentId, deletedAt) {
-    return this.updateThread(
+    return this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => applyDeleteComment(thread, commentId, deletedAt),
@@ -892,10 +972,10 @@ var UmbrellaStore = class {
     );
   }
   updateThreadAndNotification(thread, inboxNotification) {
-    this._store.batch(() => {
-      this.mutateThreadsDB((db) => db.upsertIfNewer(thread));
+    _core.batch.call(void 0, () => {
+      this.#mutateThreadsDB((db) => db.upsertIfNewer(thread));
       if (inboxNotification !== void 0) {
-        this.updateInboxNotificationsCache((cache) => ({
+        this.#updateInboxNotificationsCache((cache) => ({
           ...cache,
           [inboxNotification.id]: inboxNotification
         }));
@@ -903,11 +983,11 @@ var UmbrellaStore = class {
     });
   }
   updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
-    this._store.batch(() => {
-      this.mutateThreadsDB(
+    _core.batch.call(void 0, () => {
+      this.#mutateThreadsDB(
         (db) => applyThreadDeltaUpdates(db, { newThreads: threads, deletedThreads })
       );
-      this.updateInboxNotificationsCache(
+      this.#updateInboxNotificationsCache(
         (cache) => applyNotificationsUpdates(cache, {
           newInboxNotifications: inboxNotifications,
           deletedNotifications: deletedInboxNotifications
@@ -920,33 +1000,33 @@ var UmbrellaStore = class {
    * replacing the corresponding optimistic update.
    */
   updateRoomNotificationSettings_confirmOptimisticUpdate(roomId, optimisticUpdateId, settings) {
-    this._store.batch(() => {
+    _core.batch.call(void 0, () => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.setNotificationSettings(roomId, settings);
+      this.#setNotificationSettings(roomId, settings);
     });
   }
   addOptimisticUpdate(optimisticUpdate) {
     const id = _core.nanoid.call(void 0, );
     const newUpdate = { ...optimisticUpdate, id };
-    this.updateOptimisticUpdatesCache((cache) => [...cache, newUpdate]);
+    this.#updateOptimisticUpdatesCache((cache) => [...cache, newUpdate]);
     return id;
   }
   removeOptimisticUpdate(optimisticUpdateId) {
-    this.updateOptimisticUpdatesCache(
+    this.#updateOptimisticUpdatesCache(
       (cache) => cache.filter((ou) => ou.id !== optimisticUpdateId)
     );
   }
   async fetchNotificationsDeltaUpdate(signal) {
-    const lastRequestedAt = this._notificationsLastRequestedAt;
+    const lastRequestedAt = this.#notificationsLastRequestedAt;
     if (lastRequestedAt === null) {
       return;
     }
-    const result = await this._client.getInboxNotificationsSince({
+    const result = await this.#client.getInboxNotificationsSince({
       since: lastRequestedAt,
       signal
     });
     if (lastRequestedAt < result.requestedAt) {
-      this._notificationsLastRequestedAt = result.requestedAt;
+      this.#notificationsLastRequestedAt = result.requestedAt;
     }
     this.updateThreadsAndNotifications(
       result.threads.updated,
@@ -956,25 +1036,24 @@ var UmbrellaStore = class {
     );
   }
   waitUntilNotificationsLoaded() {
-    return this._notifications.waitUntilLoaded();
-  }
-  updateRoomPermissions(permissions) {
-    const permissionsByRoom = { ...this._store.get().permissionsByRoom };
-    Object.entries(permissions).forEach(([roomId, newPermissions]) => {
-      const existingPermissions = _nullishCoalesce(permissionsByRoom[roomId], () => ( /* @__PURE__ */ new Set()));
-      newPermissions.forEach(
-        (permission) => existingPermissions.add(permission)
-      );
-      permissionsByRoom[roomId] = existingPermissions;
+    return this.#notifications.waitUntilLoaded();
+  }
+  #updatePermissionHints(newHints) {
+    this.permissionHintsByRoomId.set((prev) => {
+      const permissionsByRoom = { ...prev };
+      for (const [roomId, newPermissions] of Object.entries(newHints)) {
+        const existing = _nullishCoalesce(permissionsByRoom[roomId], () => ( /* @__PURE__ */ new Set()));
+        for (const permission of newPermissions) {
+          existing.add(permission);
+        }
+        permissionsByRoom[roomId] = existing;
+      }
+      return permissionsByRoom;
     });
-    this._store.set((state) => ({
-      ...state,
-      permissionsByRoom
-    }));
   }
   waitUntilRoomThreadsLoaded(roomId, query) {
     const threadsFetcher = async (cursor) => {
-      const result = await this._client[_core.kInternal].httpClient.getThreads({
+      const result = await this.#client[_core.kInternal].httpClient.getThreads({
         roomId,
         cursor,
         query
@@ -983,15 +1062,15 @@ var UmbrellaStore = class {
         result.threads,
         result.inboxNotifications
       );
-      this.updateRoomPermissions(result.permissionHints);
-      const lastRequestedAt = this._roomThreadsLastRequestedAtByRoom.get(roomId);
+      this.#updatePermissionHints(result.permissionHints);
+      const lastRequestedAt = this.#roomThreadsLastRequestedAtByRoom.get(roomId);
       if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
-        this._roomThreadsLastRequestedAtByRoom.set(roomId, result.requestedAt);
+        this.#roomThreadsLastRequestedAtByRoom.set(roomId, result.requestedAt);
       }
       return result.nextCursor;
     };
     const queryKey = makeRoomThreadsQueryKey(roomId, query);
-    let paginatedResource = this._roomThreads.get(queryKey);
+    let paginatedResource = this.#roomThreads.get(queryKey);
     if (paginatedResource === void 0) {
       paginatedResource = new PaginatedResource(threadsFetcher);
     }
@@ -999,18 +1078,18 @@ var UmbrellaStore = class {
       () => (
         // Note that the store itself does not change, but it's only vehicle at
         // the moment to trigger a re-render, so we'll do a no-op update here.
-        this._store.set((store) => ({ ...store }))
+        this.invalidateEntireStore()
       )
     );
-    this._roomThreads.set(queryKey, paginatedResource);
+    this.#roomThreads.set(queryKey, paginatedResource);
     return paginatedResource.waitUntilLoaded();
   }
   async fetchRoomThreadsDeltaUpdate(roomId, signal) {
-    const lastRequestedAt = this._roomThreadsLastRequestedAtByRoom.get(roomId);
+    const lastRequestedAt = this.#roomThreadsLastRequestedAtByRoom.get(roomId);
     if (lastRequestedAt === void 0) {
       return;
     }
-    const updates = await this._client[_core.kInternal].httpClient.getThreadsSince({
+    const updates = await this.#client[_core.kInternal].httpClient.getThreadsSince({
       roomId,
       since: lastRequestedAt,
       signal
@@ -1021,15 +1100,15 @@ var UmbrellaStore = class {
       updates.threads.deleted,
       updates.inboxNotifications.deleted
     );
-    this.updateRoomPermissions(updates.permissionHints);
+    this.#updatePermissionHints(updates.permissionHints);
     if (lastRequestedAt < updates.requestedAt) {
-      this._roomThreadsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
+      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({
+      const result = await this.#client[_core.kInternal].httpClient.getUserThreads_experimental({
         cursor,
         query
       });
@@ -1037,13 +1116,13 @@ var UmbrellaStore = class {
         result.threads,
         result.inboxNotifications
       );
-      this.updateRoomPermissions(result.permissionHints);
-      if (this._userThreadsLastRequestedAt === null) {
-        this._userThreadsLastRequestedAt = result.requestedAt;
+      this.#updatePermissionHints(result.permissionHints);
+      if (this.#userThreadsLastRequestedAt === null) {
+        this.#userThreadsLastRequestedAt = result.requestedAt;
       }
       return result.nextCursor;
     };
-    let paginatedResource = this._userThreads.get(queryKey);
+    let paginatedResource = this.#userThreads.get(queryKey);
     if (paginatedResource === void 0) {
       paginatedResource = new PaginatedResource(threadsFetcher);
     }
@@ -1051,23 +1130,34 @@ var UmbrellaStore = class {
       () => (
         // Note that the store itself does not change, but it's only vehicle at
         // the moment to trigger a re-render, so we'll do a no-op update here.
-        this._store.set((store) => ({ ...store }))
+        this.invalidateEntireStore()
       )
     );
-    this._userThreads.set(queryKey, paginatedResource);
+    this.#userThreads.set(queryKey, paginatedResource);
     return paginatedResource.waitUntilLoaded();
   }
+  // TODO(vincent+nimesh) 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.baseVersionsByRoomId.set((store) => ({ ...store }));
+      this.baseNotificationsById.set((store) => ({ ...store }));
+      this.optimisticUpdates.set((store) => [...store]);
+      this.permissionHintsByRoomId.set((store) => ({ ...store }));
+      this.baseSettingsByRoomId.set((store) => ({ ...store }));
+    });
+  }
   async fetchUserThreadsDeltaUpdate(signal) {
-    const lastRequestedAt = this._userThreadsLastRequestedAt;
+    const lastRequestedAt = this.#userThreadsLastRequestedAt;
     if (lastRequestedAt === null) {
       return;
     }
-    const result = await this._client[_core.kInternal].httpClient.getUserThreadsSince_experimental({
+    const result = await this.#client[_core.kInternal].httpClient.getUserThreadsSince_experimental({
       since: lastRequestedAt,
       signal
     });
     if (lastRequestedAt < result.requestedAt) {
-      this._notificationsLastRequestedAt = result.requestedAt;
+      this.#notificationsLastRequestedAt = result.requestedAt;
     }
     this.updateThreadsAndNotifications(
       result.threads.updated,
@@ -1075,14 +1165,14 @@ var UmbrellaStore = class {
       result.threads.deleted,
       result.inboxNotifications.deleted
     );
-    this.updateRoomPermissions(result.permissionHints);
+    this.#updatePermissionHints(result.permissionHints);
   }
   waitUntilRoomVersionsLoaded(roomId) {
     const queryKey = makeVersionsQueryKey(roomId);
-    let resource = this._roomVersions.get(queryKey);
+    let resource = this.#roomVersions.get(queryKey);
     if (resource === void 0) {
       const versionsFetcher = async () => {
-        const room = this._client.getRoom(roomId);
+        const room = this.#client.getRoom(roomId);
         if (room === null) {
           throw new (0, _core.HttpError)(
             `Room '${roomId}' is not available on client`,
@@ -1090,10 +1180,10 @@ var UmbrellaStore = class {
           );
         }
         const result = await room[_core.kInternal].listTextVersions();
-        this.updateRoomVersions(roomId, result.versions);
-        const lastRequestedAt = this._roomVersionsLastRequestedAtByRoom.get(roomId);
+        this.#updateRoomVersions(roomId, result.versions);
+        const lastRequestedAt = this.#roomVersionsLastRequestedAtByRoom.get(roomId);
         if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
-          this._roomVersionsLastRequestedAtByRoom.set(
+          this.#roomVersionsLastRequestedAtByRoom.set(
             roomId,
             result.requestedAt
           );
@@ -1105,36 +1195,36 @@ var UmbrellaStore = class {
       () => (
         // Note that the store itself does not change, but it's only vehicle at
         // the moment to trigger a re-render, so we'll do a no-op update here.
-        this._store.set((store) => ({ ...store }))
+        this.invalidateEntireStore()
       )
     );
-    this._roomVersions.set(queryKey, resource);
+    this.#roomVersions.set(queryKey, resource);
     return resource.waitUntilLoaded();
   }
   async fetchRoomVersionsDeltaUpdate(roomId, signal) {
-    const lastRequestedAt = this._roomVersionsLastRequestedAtByRoom.get(roomId);
+    const lastRequestedAt = this.#roomVersionsLastRequestedAtByRoom.get(roomId);
     if (lastRequestedAt === void 0) {
       return;
     }
     const room = _core.nn.call(void 0, 
-      this._client.getRoom(roomId),
+      this.#client.getRoom(roomId),
       `Room with id ${roomId} is not available on client`
     );
     const updates = await room[_core.kInternal].listTextVersionsSince({
       since: lastRequestedAt,
       signal
     });
-    this.updateRoomVersions(roomId, updates.versions);
+    this.#updateRoomVersions(roomId, updates.versions);
     if (lastRequestedAt < updates.requestedAt) {
-      this._roomVersionsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
+      this.#roomVersionsLastRequestedAtByRoom.set(roomId, updates.requestedAt);
     }
   }
   waitUntilRoomNotificationSettingsLoaded(roomId) {
     const queryKey = makeNotificationSettingsQueryKey(roomId);
-    let resource = this._roomNotificationSettings.get(queryKey);
+    let resource = this.#roomNotificationSettings.get(queryKey);
     if (resource === void 0) {
       const notificationSettingsFetcher = async () => {
-        const room = this._client.getRoom(roomId);
+        const room = this.#client.getRoom(roomId);
         if (room === null) {
           throw new (0, _core.HttpError)(
             `Room '${roomId}' is not available on client`,
@@ -1142,7 +1232,7 @@ var UmbrellaStore = class {
           );
         }
         const result = await room.getNotificationSettings();
-        this.setNotificationSettings(roomId, result);
+        this.#setNotificationSettings(roomId, result);
       };
       resource = new SinglePageResource(notificationSettingsFetcher);
     }
@@ -1150,28 +1240,25 @@ var UmbrellaStore = class {
       () => (
         // Note that the store itself does not change, but it's only vehicle at
         // the moment to trigger a re-render, so we'll do a no-op update here.
-        this._store.set((store) => ({ ...store }))
+        this.invalidateEntireStore()
       )
     );
-    this._roomNotificationSettings.set(queryKey, resource);
+    this.#roomNotificationSettings.set(queryKey, resource);
     return resource.waitUntilLoaded();
   }
   async refreshRoomNotificationSettings(roomId, signal) {
     const room = _core.nn.call(void 0, 
-      this._client.getRoom(roomId),
+      this.#client.getRoom(roomId),
       `Room with id ${roomId} is not available on client`
     );
     const result = await room.getNotificationSettings({ signal });
-    this.setNotificationSettings(roomId, result);
+    this.#setNotificationSettings(roomId, result);
   }
 };
-function internalToExternalState(state, rawThreadsDB) {
-  const threadsDB = rawThreadsDB.clone();
-  const computed = {
-    notificationsById: { ...state.notificationsById },
-    settingsByRoomId: { ...state.settingsByRoomId }
-  };
-  for (const optimisticUpdate of state.optimisticUpdates) {
+function applyOptimisticUpdates_forThreadifications(baseThreadsDB, rawNotificationsById, optimisticUpdates) {
+  const threadsDB = baseThreadsDB.clone();
+  let notificationsById = { ...rawNotificationsById };
+  for (const optimisticUpdate of optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "create-thread": {
         threadsDB.upsert(optimisticUpdate.thread);
@@ -1209,15 +1296,13 @@ function internalToExternalState(state, rawThreadsDB) {
         const thread = threadsDB.get(optimisticUpdate.comment.threadId);
         if (thread === void 0) break;
         threadsDB.upsert(applyUpsertComment(thread, optimisticUpdate.comment));
-        const inboxNotification = Object.values(
-          computed.notificationsById
-        ).find(
+        const inboxNotification = Object.values(notificationsById).find(
           (notification) => notification.kind === "thread" && notification.threadId === thread.id
         );
         if (inboxNotification === void 0) {
           break;
         }
-        computed.notificationsById[inboxNotification.id] = {
+        notificationsById[inboxNotification.id] = {
           ...inboxNotification,
           notifiedAt: optimisticUpdate.comment.createdAt,
           readAt: optimisticUpdate.comment.createdAt
@@ -1280,23 +1365,23 @@ function internalToExternalState(state, rawThreadsDB) {
         break;
       }
       case "mark-inbox-notification-as-read": {
-        const ibn = computed.notificationsById[optimisticUpdate.inboxNotificationId];
+        const ibn = notificationsById[optimisticUpdate.inboxNotificationId];
         if (ibn === void 0) {
           break;
         }
-        computed.notificationsById[optimisticUpdate.inboxNotificationId] = {
+        notificationsById[optimisticUpdate.inboxNotificationId] = {
           ...ibn,
           readAt: optimisticUpdate.readAt
         };
         break;
       }
       case "mark-all-inbox-notifications-as-read": {
-        for (const id in computed.notificationsById) {
-          const ibn = computed.notificationsById[id];
+        for (const id in notificationsById) {
+          const ibn = notificationsById[id];
           if (ibn === void 0) {
             break;
           }
-          computed.notificationsById[id] = {
+          notificationsById[id] = {
             ...ibn,
             readAt: optimisticUpdate.readAt
           };
@@ -1304,38 +1389,44 @@ function internalToExternalState(state, rawThreadsDB) {
         break;
       }
       case "delete-inbox-notification": {
-        delete computed.notificationsById[optimisticUpdate.inboxNotificationId];
+        delete notificationsById[optimisticUpdate.inboxNotificationId];
         break;
       }
       case "delete-all-inbox-notifications": {
-        computed.notificationsById = {};
+        notificationsById = {};
         break;
       }
+    }
+  }
+  const sortedNotifications = (
+    // Sort so that the most recent notifications are first
+    Object.values(notificationsById).filter(
+      (ibn) => ibn.kind === "thread" ? threadsDB.get(ibn.threadId) !== void 0 : true
+    ).sort((a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime())
+  );
+  return {
+    sortedNotifications,
+    notificationsById,
+    threadsDB
+  };
+}
+function applyOptimisticUpdates_forSettings(baseSettingsByRoomId, optimisticUpdates) {
+  const settingsByRoomId = { ...baseSettingsByRoomId };
+  for (const optimisticUpdate of optimisticUpdates) {
+    switch (optimisticUpdate.type) {
       case "update-notification-settings": {
-        const settings = computed.settingsByRoomId[optimisticUpdate.roomId];
+        const settings = settingsByRoomId[optimisticUpdate.roomId];
         if (settings === void 0) {
           break;
         }
-        computed.settingsByRoomId[optimisticUpdate.roomId] = {
+        settingsByRoomId[optimisticUpdate.roomId] = {
           ...settings,
           ...optimisticUpdate.settings
         };
       }
     }
   }
-  const cleanedNotifications = (
-    // Sort so that the most recent notifications are first
-    Object.values(computed.notificationsById).filter(
-      (ibn) => ibn.kind === "thread" ? threadsDB.get(ibn.threadId) !== void 0 : true
-    ).sort((a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime())
-  );
-  return {
-    cleanedNotifications,
-    notificationsById: computed.notificationsById,
-    settingsByRoomId: computed.settingsByRoomId,
-    threadsDB,
-    versionsByRoomId: state.versionsByRoomId
-  };
+  return settingsByRoomId;
 }
 function applyThreadDeltaUpdates(db, updates) {
   updates.newThreads.forEach((thread) => db.upsertIfNewer(thread));
@@ -1717,7 +1808,7 @@ function useInboxNotifications_withClient(client, selector, isEqual) {
     };
   }, [poller]);
   return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe1_threads,
     store.getInboxNotificationsLoadingState,
     store.getInboxNotificationsLoadingState,
     selector,
@@ -1839,7 +1930,7 @@ function useDeleteAllInboxNotifications_withClient(client) {
 }
 function useInboxNotificationThread_withClient(client, inboxNotificationId) {
   const { store } = getLiveblocksExtrasForClient(client);
-  const getter = store.getFullState;
+  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`)));
@@ -1856,7 +1947,7 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
     [inboxNotificationId]
   );
   return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe1_both,
     // Re-evaluate if we need to update any time the notification changes over time
     getter,
     getter,
@@ -2072,7 +2163,7 @@ function useUserThreads_experimental(options = {
     [store, options.query]
   );
   return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe1_threads,
     getter,
     getter,
     identity,
@@ -2281,8 +2372,21 @@ var UpdateNotificationSettingsError = class extends Error {
   }
 };
 
+// src/use-signal.ts
+
+var identity2 = (value) => value;
+function useSignal(signal, selector, isEqual) {
+  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+    signal.subscribe,
+    signal.get,
+    signal.get,
+    _nullishCoalesce(selector, () => ( identity2)),
+    isEqual
+  );
+}
+
 // src/room.tsx
-var _client2 = require('@liveblocks/client');
+var _client = require('@liveblocks/client');
 
 
 
@@ -2331,7 +2435,7 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 // src/room.tsx
 var noop3 = () => {
 };
-var identity2 = (x) => x;
+var identity3 = (x) => x;
 var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\u2019re using React ${reactVersion}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
 
     import { unstable_batchedUpdates } from "react-dom";  // or "react-native"
@@ -2345,7 +2449,7 @@ var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\
 Why? Please see https://liveblocks.io/docs/platform/troubleshooting#stale-props-zombie-child for more information`;
 var superfluous_unstable_batchedUpdates = "You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";
 function useSyncExternalStore2(s, gs, gss) {
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, s, gs, gss, identity2);
+  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, s, gs, gss, identity3);
 }
 var STABLE_EMPTY_LIST = Object.freeze([]);
 function alwaysEmptyList() {
@@ -2387,7 +2491,7 @@ function makeMutationContext(room) {
   };
 }
 function getCurrentUserId(client) {
-  const userId = client[_core.kInternal].currentUserIdStore.get();
+  const userId = client[_core.kInternal].currentUserId.get();
   if (userId === void 0) {
     return "anonymous";
   }
@@ -2685,7 +2789,7 @@ function RoomProviderInner(props) {
         return;
       }
       const { thread, inboxNotification } = info;
-      const existingThread = store.getFullState().threadsDB.getEvenIfDeleted(message.threadId);
+      const existingThread = store.get1_threads().threadsDB.getEvenIfDeleted(message.threadId);
       switch (message.type) {
         case _core.ServerMsgCode.COMMENT_EDITED:
         case _core.ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -2750,6 +2854,52 @@ function useReportTextEditor(editor, rootKey) {
     return unsubscribe;
   }, [room, editor, rootKey]);
 }
+function useYjsProvider() {
+  const room = useRoom();
+  const subscribe = React4.useCallback(
+    (onStoreChange) => {
+      return room[_core.kInternal].yjsProviderDidChange.subscribe(onStoreChange);
+    },
+    [room]
+  );
+  const getSnapshot = React4.useCallback(() => {
+    return room[_core.kInternal].getYjsProvider();
+  }, [room]);
+  return useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+}
+function useCreateTextMention() {
+  const room = useRoom();
+  return React4.useCallback(
+    (userId, mentionId) => {
+      room[_core.kInternal].createTextMention(userId, mentionId).catch((err) => {
+        _core.console.error(
+          `Cannot create text mention for user '${userId}' and mention '${mentionId}'`,
+          err
+        );
+      });
+    },
+    [room]
+  );
+}
+function useDeleteTextMention() {
+  const room = useRoom();
+  return React4.useCallback(
+    (mentionId) => {
+      room[_core.kInternal].deleteTextMention(mentionId).catch((err) => {
+        _core.console.error(`Cannot delete text mention '${mentionId}'`, err);
+      });
+    },
+    [room]
+  );
+}
+function useResolveMentionSuggestions() {
+  const client = useClient();
+  return client[_core.kInternal].resolveMentionSuggestions;
+}
+function useMentionSuggestionsCache() {
+  const client = useClient();
+  return client[_core.kInternal].mentionSuggestionsCache;
+}
 function useStorageStatus(options) {
   const smooth = useInitial(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.smooth]), () => ( false)));
   if (smooth) {
@@ -2859,7 +3009,7 @@ function useSelf(maybeSelector, isEqual) {
   const room = useRoom();
   const subscribe = room.events.self.subscribe;
   const getSnapshot = room.getSelf;
-  const selector = _nullishCoalesce(maybeSelector, () => ( identity2));
+  const selector = _nullishCoalesce(maybeSelector, () => ( identity3));
   const wrappedSelector = React4.useCallback(
     (me) => me !== null ? selector(me) : null,
     [selector]
@@ -2893,7 +3043,7 @@ function useOthers(selector, isEqual) {
     subscribe,
     getSnapshot,
     getServerSnapshot,
-    _nullishCoalesce(selector, () => ( identity2)),
+    _nullishCoalesce(selector, () => ( identity3)),
     isEqual
   );
 }
@@ -2915,7 +3065,7 @@ function useOthersMapped(itemSelector, itemIsEqual) {
   return useOthers(wrappedSelector, wrappedIsEqual);
 }
 function useOthersConnectionIds() {
-  return useOthers(selectorFor_useOthersConnectionIds, _client2.shallow);
+  return useOthers(selectorFor_useOthersConnectionIds, _client.shallow);
 }
 var NOT_FOUND = Symbol();
 function useOther(connectionId, selector, isEqual) {
@@ -3035,10 +3185,10 @@ function useThreads(options = {
     [store, room.id, options.query]
   );
   const state = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe1_threads,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
     // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
   );
@@ -3131,7 +3281,7 @@ function useDeleteRoomThread(roomId) {
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const userId = getCurrentUserId(client);
-      const existing = store.getFullState().threadsDB.get(threadId);
+      const existing = store.get1_threads().threadsDB.get(threadId);
       if (_optionalChain([existing, 'optionalAccess', _17 => _17.comments, 'optionalAccess', _18 => _18[0], 'optionalAccess', _19 => _19.userId]) !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
@@ -3254,7 +3404,7 @@ function useEditRoomComment(roomId) {
     ({ threadId, commentId, body, attachments }) => {
       const editedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const existing = store.getFullState().threadsDB.getEvenIfDeleted(threadId);
+      const existing = store.get1_threads().threadsDB.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.`
@@ -3436,7 +3586,7 @@ function useMarkRoomThreadAsRead(roomId) {
     (threadId) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const inboxNotification = Object.values(
-        store.getFullState().notificationsById
+        store.get1_notifications().notificationsById
       ).find(
         (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
       );
@@ -3548,9 +3698,10 @@ function useMarkRoomThreadAsUnresolved(roomId) {
 function useThreadSubscription(threadId) {
   const client = useClient();
   const { store } = getRoomExtrasForClient(client);
+  const signal = store.outputs.threadifications;
   const selector = React4.useCallback(
     (state) => {
-      const notification = state.cleanedNotifications.find(
+      const notification = state.sortedNotifications.find(
         (inboxNotification) => inboxNotification.kind === "thread" && inboxNotification.threadId === threadId
       );
       const thread = state.threadsDB.get(threadId);
@@ -3564,12 +3715,7 @@ function useThreadSubscription(threadId) {
     },
     [threadId]
   );
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
-    store.getFullState,
-    store.getFullState,
-    selector
-  );
+  return useSignal(signal, selector, _client.shallow);
 }
 function useRoomNotificationSettings() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
@@ -3602,10 +3748,10 @@ function useRoomNotificationSettings() {
     [store, room.id]
   );
   const settings = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe2,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
   return React4.useMemo(() => {
@@ -3681,10 +3827,10 @@ function useHistoryVersions() {
     //    *next* render after that, a *new* fetch/promise will get created.
   );
   const state = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+    store.subscribe3,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
   return state;
@@ -3828,7 +3974,7 @@ function useRoomAttachmentUrl(attachmentId, roomId) {
     getAttachmentUrlState,
     getAttachmentUrlState,
     selectorFor_useAttachmentUrl,
-    _client2.shallow
+    _client.shallow
   );
 }
 function useAttachmentUrlSuspense(attachmentId) {
@@ -3862,11 +4008,10 @@ function useAttachmentUrlSuspense(attachmentId) {
 function useRoomPermissions(roomId) {
   const client = useClient();
   const store = getRoomExtrasForClient(client).store;
-  return _nullishCoalesce(useSyncExternalStore2(
-    store.subscribe,
-    React4.useCallback(() => store._getPermissions(roomId), [store, roomId]),
-    React4.useCallback(() => store._getPermissions(roomId), [store, roomId])
-  ), () => ( /* @__PURE__ */ new Set()));
+  return useSignal(
+    store.permissionHintsByRoomId,
+    (hints) => _nullishCoalesce(hints[roomId], () => ( /* @__PURE__ */ new Set()))
+  );
 }
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
@@ -4007,5 +4152,11 @@ var _useUpdateMyPresence = useUpdateMyPresence;
 
 
 
-exports.RoomContext = RoomContext; exports.useRoomOrNull = useRoomOrNull; 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.useStatus = useStatus; exports.useReportTextEditor = useReportTextEditor; 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-X4DDEZYL.js.map
+
+
+
+
+
+
+exports.RoomContext = RoomContext; exports.useRoomOrNull = useRoomOrNull; 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-N33NEN5R.js.map