@liveblocks/react 2.14.0 → 2.15.0-debug1

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

@@ -1,14 +1,90 @@
 // src/contexts.ts
-import * as React from "react";
-var RoomContext = React.createContext(null);
+import { createContext, useContext } from "react";
+var RoomContext = createContext(null);
 function useRoomOrNull() {
-  return React.useContext(RoomContext);
+  return useContext(RoomContext);
 }
 function useIsInsideRoom() {
   const room = useRoomOrNull();
   return room !== null;
 }
 
+// src/use-sync-external-store-with-selector.ts
+import {
+  useDebugValue,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore
+} from "react";
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+}
+function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+  const instRef = useRef(null);
+  let inst;
+  if (instRef.current === null) {
+    inst = {
+      hasValue: false,
+      value: null
+    };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+  const [getSelection, getServerSelection] = useMemo(() => {
+    let hasMemo = false;
+    let memoizedSnapshot;
+    let memoizedSelection;
+    const memoizedSelector = (nextSnapshot) => {
+      if (!hasMemo) {
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+        const nextSelection2 = selector(nextSnapshot);
+        if (isEqual !== void 0) {
+          if (inst.hasValue) {
+            const currentSelection = inst.value;
+            if (isEqual(currentSelection, nextSelection2)) {
+              memoizedSelection = currentSelection;
+              return currentSelection;
+            }
+          }
+        }
+        memoizedSelection = nextSelection2;
+        return nextSelection2;
+      }
+      const prevSnapshot = memoizedSnapshot;
+      const prevSelection = memoizedSelection;
+      if (is(prevSnapshot, nextSnapshot)) {
+        return prevSelection;
+      }
+      const nextSelection = selector(nextSnapshot);
+      if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
+        memoizedSnapshot = nextSnapshot;
+        return prevSelection;
+      }
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    };
+    const maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
+    const getSnapshotWithSelector = () => memoizedSelector(getSnapshot());
+    const getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : () => memoizedSelector(maybeGetServerSnapshot());
+    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+  }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+  const value = useSyncExternalStore(
+    subscribe,
+    getSelection,
+    getServerSelection
+  );
+  useEffect(() => {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [value]);
+  useDebugValue(value);
+  return value;
+}
+
 // src/liveblocks.tsx
 import {
   assert,
@@ -18,15 +94,15 @@ import {
   raise,
   shallow as shallow3
 } from "@liveblocks/core";
-import React2, {
+import {
   createContext as createContext2,
   useCallback as useCallback2,
   useContext as useContext2,
-  useEffect as useEffect2,
-  useMemo
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useState,
+  useSyncExternalStore as useSyncExternalStore2
 } from "react";
-import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
-import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
 
 // src/config.ts
 var SECONDS = 1e3;
@@ -64,10 +140,10 @@ function shallow2(a, b) {
 import { useCallback, useReducer } from "react";
 
 // src/lib/use-latest.ts
-import { useEffect, useRef } from "react";
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
 function useLatest(value) {
-  const ref = useRef(value);
-  useEffect(() => {
+  const ref = useRef2(value);
+  useEffect2(() => {
     ref.current = value;
   }, [value]);
   return ref;
@@ -120,15 +196,17 @@ var use = (
 // src/umbrella-store.ts
 import {
   autoRetry,
+  batch,
   compactObject,
   console as console2,
-  createStore,
+  DerivedSignal,
   HttpError,
   kInternal,
   makeEventSource,
   mapValues,
   nanoid,
   nn,
+  Signal,
   stringify
 } from "@liveblocks/core";
 
@@ -150,7 +228,7 @@ function autobind(self) {
 }
 
 // src/ThreadDB.ts
-import { SortedList } from "@liveblocks/core";
+import { MutableSignal, SortedList } from "@liveblocks/core";
 
 // src/lib/guards.ts
 import { isPlainObject as isPlainObject2 } from "@liveblocks/core";
@@ -202,36 +280,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
+  signal;
   constructor() {
-    this._asc = SortedList.from([], (t1, t2) => {
+    this.#asc = SortedList.from([], (t1, t2) => {
       const d1 = t1.createdAt;
       const d2 = t2.createdAt;
       return d1 < d2 ? true : d1 === d2 ? t1.id < t2.id : false;
     });
-    this._desc = SortedList.from([], (t1, t2) => {
+    this.#desc = SortedList.from([], (t1, t2) => {
       const d2 = t2.updatedAt;
       const d1 = t1.updatedAt;
       return d2 < d1 ? true : d2 === d1 ? t2.id < t1.id : false;
     });
-    this._byId = /* @__PURE__ */ new Map();
-    this._version = 0;
+    this.#byId = /* @__PURE__ */ new Map();
+    this.signal = new 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 +316,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 +351,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 +368,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 +376,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 +412,67 @@ function usify(promise) {
 var noop2 = Promise.resolve();
 var ASYNC_LOADING = Object.freeze({ isLoading: true });
 var PaginatedResource = class {
+  observable;
+  #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 = makeEventSource();
-    this._pendingFetchMore = null;
-    this.observable = this._eventSource.observable;
+    this.#paginationState = null;
+    this.#fetchPage = fetchPage;
+    this.#eventSource = makeEventSource();
+    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 (!state?.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 (state?.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 +483,13 @@ var PaginatedResource = class {
       }
     };
   }
+  #cachedPromise = null;
   waitUntilLoaded() {
-    if (this._cachedPromise) {
-      return this._cachedPromise;
+    if (this.#cachedPromise) {
+      return this.#cachedPromise;
     }
     const initialFetcher = autoRetry(
-      () => this._fetchPage(
+      () => this.#fetchPage(
         /* cursor */
         void 0
       ),
@@ -419,7 +498,7 @@ var PaginatedResource = class {
     );
     const promise = usify(
       initialFetcher.then((cursor) => {
-        this._paginationState = {
+        this.#paginationState = {
           cursor,
           isFetchingMore: false,
           fetchMoreError: void 0
@@ -427,29 +506,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 {
+  observable;
+  #eventSource;
+  #fetchPage;
   constructor(fetchPage) {
-    this._cachedPromise = null;
-    this._fetchPage = fetchPage;
-    this._eventSource = makeEventSource();
-    this.observable = this._eventSource.observable;
+    this.#fetchPage = fetchPage;
+    this.#eventSource = makeEventSource();
+    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 +542,187 @@ var SinglePageResource = class {
       data: void 0
     };
   }
+  #cachedPromise = null;
   waitUntilLoaded() {
-    if (this._cachedPromise) {
-      return this._cachedPromise;
+    if (this.#cachedPromise) {
+      return this.#cachedPromise;
     }
     const initialFetcher = autoRetry(
-      () => 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.)
+  //
+  baseThreadsDB;
+  // Exposes its signal under `.signal` prop
+  baseNotificationsById;
+  baseSettingsByRoomId;
+  optimisticUpdates;
+  baseVersionsByRoomId;
+  permissionHintsByRoomId;
+  //
+  // 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.
+  //
+  outputs;
+  // Notifications
+  #notificationsLastRequestedAt = null;
+  // Keeps track of when we successfully requested an inbox notifications update for the last time. Will be `null` as long as the first successful fetch hasn't happened yet.
+  #notifications;
+  // 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[kInternal].as();
-    this._syncSource = this._client[kInternal].createSyncSource();
+    this.#client = client[kInternal].as();
+    this.#syncSource = this.#client[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 Signal([]);
+    this.baseVersionsByRoomId = new Signal({});
+    this.baseNotificationsById = new Signal({});
+    this.baseSettingsByRoomId = new Signal({});
+    this.permissionHintsByRoomId = new Signal({});
+    const threadifications = DerivedSignal.from(
+      this.baseThreadsDB.signal,
+      this.baseNotificationsById,
+      this.optimisticUpdates,
+      (ts, ns, updates) => applyOptimisticUpdates_forThreadifications(ts, ns, updates)
+    );
+    const threads = DerivedSignal.from(threadifications, (s) => ({
+      threadsDB: s.threadsDB
+    }));
+    const notifications = DerivedSignal.from(threadifications, (s) => ({
+      sortedNotifications: s.sortedNotifications,
+      notificationsById: s.notificationsById
+    }));
+    const settingsByRoomId = DerivedSignal.from(
+      this.baseSettingsByRoomId,
+      this.optimisticUpdates,
+      (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
+    );
+    const versionsByRoomId = 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 = createStore({
-      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();
   }
-  batch(callback) {
-    return this._store.batch(callback);
+  subscribe1_both(callback) {
+    return this.outputs.threadifications.subscribe(callback);
   }
-  getFullState() {
-    return this.get();
+  get1_threads() {
+    return this.outputs.threads.get();
+  }
+  subscribe1_threads(callback) {
+    return this.outputs.threads.subscribe(callback);
+  }
+  get1_notifications() {
+    return this.outputs.notifications.get();
+  }
+  subscribe1_notifications(callback) {
+    return this.outputs.notifications.subscribe(callback);
+  }
+  get2() {
+    return this.outputs.settingsByRoomId.get();
+  }
+  subscribe2(callback) {
+    return this.outputs.settingsByRoomId.subscribe(callback);
+  }
+  get3() {
+    return this.outputs.versionsByRoomId.get();
+  }
+  subscribe3(callback) {
+    return this.outputs.versionsByRoomId.subscribe(callback);
   }
   /**
    * Returns the async result of the given query and room id. If the query is success,
@@ -558,7 +731,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 +739,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,
       query ?? {},
       "asc"
@@ -583,7 +756,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 +764,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
       query ?? {},
@@ -609,14 +782,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 +797,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 +810,12 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      settings: nn(this.get().settingsByRoomId[roomId])
+      settings: nn(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 +825,53 @@ var UmbrellaStore = class {
     }
     return {
       isLoading: false,
-      versions: Object.values(this.get().versionsByRoomId[roomId] ?? {})
+      versions: Object.values(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) {
+    batch(() => {
+      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 version of versions) {
+        newVersions[version.id] = version;
+      }
       return {
-        ...state,
-        versionsByRoomId: {
-          ...state.versionsByRoomId,
-          [roomId]: {
-            // Merge with existing versions for the room, or start with an empty object
-            ...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) {
+    batch(() => {
+      this.baseVersionsByRoomId.set(callback);
+      this.invalidateEntireStore();
+    });
+  }
+  /** @internal - Only call this method from unit tests. */
+  force_set_notifications(callback) {
+    batch(() => {
+      this.baseNotificationsById.set(callback);
+      this.invalidateEntireStore();
+    });
   }
   /**
    * Updates an existing inbox notification with a new value, replacing the
@@ -724,18 +881,17 @@ var UmbrellaStore = class {
    * the cache.
    */
   updateInboxNotification(inboxNotificationId, optimisticUpdateId, callback) {
-    this._store.batch(() => {
+    batch(() => {
       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 +900,9 @@ var UmbrellaStore = class {
    * them, replacing the corresponding optimistic update.
    */
   updateAllInboxNotifications(optimisticUpdateId, mapFn) {
-    this._store.batch(() => {
+    batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => mapValues(cache, mapFn));
+      this.#updateInboxNotificationsCache((cache) => mapValues(cache, mapFn));
     });
   }
   /**
@@ -754,9 +910,9 @@ var UmbrellaStore = class {
    * optimistic update.
    */
   deleteInboxNotification(inboxNotificationId, optimisticUpdateId) {
-    this._store.batch(() => {
+    batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => {
+      this.#updateInboxNotificationsCache((cache) => {
         const { [inboxNotificationId]: removed, ...newCache } = cache;
         return removed === void 0 ? cache : newCache;
       });
@@ -767,18 +923,18 @@ var UmbrellaStore = class {
    * update.
    */
   deleteAllInboxNotifications(optimisticUpdateId) {
-    this._store.batch(() => {
+    batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache(() => ({}));
+      this.#updateInboxNotificationsCache(() => ({}));
     });
   }
   /**
    * Creates an new thread, replacing the corresponding optimistic update.
    */
   createThread(optimisticUpdateId, thread) {
-    this._store.batch(() => {
+    batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.mutateThreadsDB((db) => db.upsert(thread));
+      this.#mutateThreadsDB((db) => db.upsert(thread));
     });
   }
   /**
@@ -791,12 +947,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) {
+    batch(() => {
       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 +961,7 @@ var UmbrellaStore = class {
     });
   }
   patchThread(threadId, optimisticUpdateId, patch, updatedAt) {
-    return this.updateThread(
+    return this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => ({ ...thread, ...compactObject(patch) }),
@@ -813,7 +969,7 @@ var UmbrellaStore = class {
     );
   }
   addReaction(threadId, optimisticUpdateId, commentId, reaction, createdAt) {
-    this.updateThread(
+    this.#updateThread(
       threadId,
       optimisticUpdateId,
       (thread) => applyAddReaction(thread, commentId, reaction),
@@ -821,7 +977,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 +993,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 +1005,16 @@ var UmbrellaStore = class {
    * updated correctly, replacing the corresponding optimistic update.
    */
   createComment(newComment, optimisticUpdateId) {
-    this._store.batch(() => {
+    batch(() => {
       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 +1033,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 +1048,10 @@ var UmbrellaStore = class {
     );
   }
   updateThreadAndNotification(thread, inboxNotification) {
-    this._store.batch(() => {
-      this.mutateThreadsDB((db) => db.upsertIfNewer(thread));
+    batch(() => {
+      this.#mutateThreadsDB((db) => db.upsertIfNewer(thread));
       if (inboxNotification !== void 0) {
-        this.updateInboxNotificationsCache((cache) => ({
+        this.#updateInboxNotificationsCache((cache) => ({
           ...cache,
           [inboxNotification.id]: inboxNotification
         }));
@@ -903,11 +1059,11 @@ var UmbrellaStore = class {
     });
   }
   updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
-    this._store.batch(() => {
-      this.mutateThreadsDB(
+    batch(() => {
+      this.#mutateThreadsDB(
         (db) => applyThreadDeltaUpdates(db, { newThreads: threads, deletedThreads })
       );
-      this.updateInboxNotificationsCache(
+      this.#updateInboxNotificationsCache(
         (cache) => applyNotificationsUpdates(cache, {
           newInboxNotifications: inboxNotifications,
           deletedNotifications: deletedInboxNotifications
@@ -920,33 +1076,33 @@ var UmbrellaStore = class {
    * replacing the corresponding optimistic update.
    */
   updateRoomNotificationSettings_confirmOptimisticUpdate(roomId, optimisticUpdateId, settings) {
-    this._store.batch(() => {
+    batch(() => {
       this.removeOptimisticUpdate(optimisticUpdateId);
-      this.setNotificationSettings(roomId, settings);
+      this.#setNotificationSettings(roomId, settings);
     });
   }
   addOptimisticUpdate(optimisticUpdate) {
     const id = nanoid();
     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 +1112,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 = 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 = 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[kInternal].httpClient.getThreads({
+      const result = await this.#client[kInternal].httpClient.getThreads({
         roomId,
         cursor,
         query
@@ -983,15 +1138,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 +1154,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[kInternal].httpClient.getThreadsSince({
+    const updates = await this.#client[kInternal].httpClient.getThreadsSince({
       roomId,
       since: lastRequestedAt,
       signal
@@ -1021,15 +1176,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[kInternal].httpClient.getUserThreads_experimental({
+      const result = await this.#client[kInternal].httpClient.getUserThreads_experimental({
         cursor,
         query
       });
@@ -1037,13 +1192,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 +1206,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() {
+    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 }));
+    });
+  }
   async fetchUserThreadsDeltaUpdate(signal) {
-    const lastRequestedAt = this._userThreadsLastRequestedAt;
+    const lastRequestedAt = this.#userThreadsLastRequestedAt;
     if (lastRequestedAt === null) {
       return;
     }
-    const result = await this._client[kInternal].httpClient.getUserThreadsSince_experimental({
+    const result = await this.#client[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 +1241,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 HttpError(
             `Room '${roomId}' is not available on client`,
@@ -1090,10 +1256,10 @@ var UmbrellaStore = class {
           );
         }
         const result = await room[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 +1271,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 = nn(
-      this._client.getRoom(roomId),
+      this.#client.getRoom(roomId),
       `Room with id ${roomId} is not available on client`
     );
     const updates = await room[kInternal].listTextVersionsSince({
       since: lastRequestedAt,
       signal
     });
-    this.updateRoomVersions(roomId, updates.versions);
+    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 HttpError(
             `Room '${roomId}' is not available on client`,
@@ -1142,7 +1308,7 @@ var UmbrellaStore = class {
           );
         }
         const result = await room.getNotificationSettings();
-        this.setNotificationSettings(roomId, result);
+        this.#setNotificationSettings(roomId, result);
       };
       resource = new SinglePageResource(notificationSettingsFetcher);
     }
@@ -1150,28 +1316,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 = nn(
-      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 +1372,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 +1441,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 +1465,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));
@@ -1542,6 +1709,7 @@ function upsertReaction(reactions, reaction) {
 }
 
 // src/liveblocks.tsx
+import { jsx } from "react/jsx-runtime";
 var ClientContext = createContext2(null);
 function missingUserError(userId) {
   return new Error(`resolveUsers didn't return anything for user '${userId}'`);
@@ -1675,7 +1843,7 @@ function makeLiveblocksContextBundle(client) {
   const useDeleteAllInboxNotifications2 = () => useDeleteAllInboxNotifications_withClient(client);
   function LiveblocksProvider2(props) {
     useEnsureNoLiveblocksProvider();
-    return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: client }, props.children);
+    return /* @__PURE__ */ jsx(ClientContext.Provider, { value: client, children: props.children });
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -1706,10 +1874,10 @@ function makeLiveblocksContextBundle(client) {
 }
 function useInboxNotifications_withClient(client, selector, isEqual) {
   const { store, notificationsPoller: poller } = getLiveblocksExtrasForClient(client);
-  useEffect2(() => {
+  useEffect3(() => {
     void store.waitUntilNotificationsLoaded();
   });
-  useEffect2(() => {
+  useEffect3(() => {
     poller.inc();
     poller.pollNowIfStale();
     return () => {
@@ -1717,7 +1885,7 @@ function useInboxNotifications_withClient(client, selector, isEqual) {
     };
   }, [poller]);
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
+    store.subscribe1_threads,
     store.getInboxNotificationsLoadingState,
     store.getInboxNotificationsLoadingState,
     selector,
@@ -1839,7 +2007,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 = useCallback2(
     (state) => {
       const inboxNotification = state.notificationsById[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
@@ -1856,7 +2024,7 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
     [inboxNotificationId]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
+    store.subscribe1_both,
     // Re-evaluate if we need to update any time the notification changes over time
     getter,
     getter,
@@ -1880,7 +2048,7 @@ function useUser_withClient(client, userId) {
     selector,
     shallow3
   );
-  useEffect2(() => {
+  useEffect3(() => {
     void usersStore.get(userId);
   }, [usersStore, userId, result]);
   return result;
@@ -1901,7 +2069,7 @@ function useUserSuspense_withClient(client, userId) {
   if (!userState.data) {
     throw missingUserError(userId);
   }
-  const state = useSyncExternalStore(
+  const state = useSyncExternalStore2(
     usersStore.subscribe,
     getUserState,
     getUserState
@@ -1932,7 +2100,7 @@ function useRoomInfo_withClient(client, roomId) {
     selector,
     shallow3
   );
-  useEffect2(() => {
+  useEffect3(() => {
     void roomsInfoStore.get(roomId);
   }, [roomsInfoStore, roomId, result]);
   return result;
@@ -1953,7 +2121,7 @@ function useRoomInfoSuspense_withClient(client, roomId) {
   if (!roomInfoState.data) {
     throw missingRoomInfoError(roomId);
   }
-  const state = useSyncExternalStore(
+  const state = useSyncExternalStore2(
     roomsInfoStore.subscribe,
     getRoomInfoState,
     getRoomInfoState
@@ -2006,7 +2174,7 @@ function useClient() {
 }
 function LiveblocksProviderWithClient(props) {
   useEnsureNoLiveblocksProvider(props);
-  return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: props.client }, props.children);
+  return /* @__PURE__ */ jsx(ClientContext.Provider, { value: props.client, children: props.children });
 }
 function LiveblocksProvider(props) {
   const { children, ...o } = props;
@@ -2034,8 +2202,8 @@ function LiveblocksProvider(props) {
       o.enableDebugLogging
     )
   };
-  const client = useMemo(() => createClient(options), []);
-  return /* @__PURE__ */ React2.createElement(LiveblocksProviderWithClient, { client }, children);
+  const client = useMemo2(() => createClient(options), []);
+  return /* @__PURE__ */ jsx(LiveblocksProviderWithClient, { client, children });
 }
 function createLiveblocksContext(client) {
   return getOrCreateContextBundle(client);
@@ -2047,7 +2215,7 @@ function useUserThreads_experimental(options = {
 }) {
   const client = useClient();
   const { store, userThreadsPoller: poller } = getLiveblocksExtrasForClient(client);
-  useEffect2(
+  useEffect3(
     () => {
       void store.waitUntilUserThreadsLoaded(options.query);
     }
@@ -2060,7 +2228,7 @@ function useUserThreads_experimental(options = {
     // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
     //    *next* render after that, a *new* fetch/promise will get created.
   );
-  useEffect2(() => {
+  useEffect3(() => {
     poller.inc();
     poller.pollNowIfStale();
     return () => {
@@ -2072,7 +2240,7 @@ function useUserThreads_experimental(options = {
     [store, options.query]
   );
   return useSyncExternalStoreWithSelector(
-    store.subscribe,
+    store.subscribe1_threads,
     getter,
     getter,
     identity,
@@ -2151,7 +2319,7 @@ function useSyncStatus_withClient(client, options) {
   }
 }
 function useSyncStatusImmediate_withClient(client) {
-  return useSyncExternalStore(
+  return useSyncExternalStore2(
     client.events.syncStatus.subscribe,
     client.getSyncStatus,
     client.getSyncStatus
@@ -2159,9 +2327,9 @@ function useSyncStatusImmediate_withClient(client) {
 }
 function useSyncStatusSmooth_withClient(client) {
   const getter = client.getSyncStatus;
-  const [status, setStatus] = React2.useState(getter);
+  const [status, setStatus] = useState(getter);
   const oldStatus = useLatest(getter());
-  React2.useEffect(() => {
+  useEffect3(() => {
     let timeoutId;
     const unsub = client.events.syncStatus.subscribe(() => {
       const newStatus = getter();
@@ -2281,6 +2449,18 @@ var UpdateNotificationSettingsError = class extends Error {
   }
 };
 
+// src/use-signal.ts
+var identity2 = (value) => value;
+function useSignal(signal, selector, isEqual) {
+  return useSyncExternalStoreWithSelector(
+    signal.subscribe,
+    signal.get,
+    signal.get,
+    selector ?? identity2,
+    isEqual
+  );
+}
+
 // src/room.tsx
 import { shallow as shallow4 } from "@liveblocks/client";
 import {
@@ -2288,7 +2468,6 @@ import {
   console as console3,
   createCommentId,
   createThreadId,
-  deprecateIf,
   errorIf,
   HttpError as HttpError2,
   kInternal as kInternal3,
@@ -2296,11 +2475,18 @@ import {
   makePoller as makePoller2,
   ServerMsgCode
 } from "@liveblocks/core";
-import * as React4 from "react";
-import { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from "use-sync-external-store/shim/with-selector.js";
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect5,
+  useMemo as useMemo3,
+  useRef as useRef3,
+  useState as useState2,
+  useSyncExternalStore as useSyncExternalStore3,
+  version as reactVersion
+} from "react";
 
 // src/use-scroll-to-comment-on-load-effect.ts
-import * as React3 from "react";
+import { useEffect as useEffect4 } from "react";
 function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
   if (shouldScrollOnLoad === false) return;
   if (!state.threads) return;
@@ -2319,7 +2505,7 @@ function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
   comment.scrollIntoView();
 }
 function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
-  React3.useEffect(
+  useEffect4(
     () => {
       handleScrollToCommentOnLoad(shouldScrollOnLoad, state);
     },
@@ -2329,24 +2515,10 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 }
 
 // src/room.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
 var noop3 = () => {
 };
-var identity2 = (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"
-
-    <RoomProvider id=${JSON.stringify(
-  roomId
-)} ... unstable_batchedUpdates={unstable_batchedUpdates}>
-      ...
-    </RoomProvider>
-
-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 useSyncExternalStoreWithSelector2(s, gs, gss, identity2);
-}
+var identity3 = (x) => x;
 var STABLE_EMPTY_LIST = Object.freeze([]);
 function alwaysEmptyList() {
   return STABLE_EMPTY_LIST;
@@ -2387,7 +2559,7 @@ function makeMutationContext(room) {
   };
 }
 function getCurrentUserId(client) {
-  const userId = client[kInternal3].currentUserIdStore.get();
+  const userId = client[kInternal3].currentUserId.get();
   if (userId === void 0) {
     return "anonymous";
   }
@@ -2506,7 +2678,7 @@ function makeRoomExtrasForClient(client) {
 }
 function makeRoomContextBundle(client) {
   function RoomProvider_withImplicitLiveblocksProvider(props) {
-    return /* @__PURE__ */ React4.createElement(LiveblocksProviderWithClient, { client, allowNesting: true }, /* @__PURE__ */ React4.createElement(RoomProvider, { ...props }));
+    return /* @__PURE__ */ jsx2(LiveblocksProviderWithClient, { client, allowNesting: true, children: /* @__PURE__ */ jsx2(RoomProvider, { ...props }) });
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -2610,10 +2782,10 @@ function makeRoomContextBundle(client) {
 }
 function RoomProvider(props) {
   const client = useClient();
-  const [cache] = React4.useState(
+  const [cache] = useState2(
     () => /* @__PURE__ */ new Map()
   );
-  const stableEnterRoom = React4.useCallback(
+  const stableEnterRoom = useCallback3(
     (roomId, options) => {
       const cached = cache.get(roomId);
       if (cached) return cached;
@@ -2628,7 +2800,7 @@ function RoomProvider(props) {
     },
     [client, cache]
   );
-  return /* @__PURE__ */ React4.createElement(
+  return /* @__PURE__ */ jsx2(
     RoomProviderInner,
     {
       ...props,
@@ -2648,31 +2820,26 @@ function RoomProviderInner(props) {
     if (!isString(roomId)) {
       throw new Error("RoomProvider id property should be a string.");
     }
-    const majorReactVersion = parseInt(React4.version) || 1;
-    const oldReactVersion = majorReactVersion < 18;
+    const majorReactVersion = parseInt(reactVersion) || 1;
+    const requiredVersion = 18;
     errorIf(
-      oldReactVersion && props.unstable_batchedUpdates === void 0,
-      missing_unstable_batchedUpdates(majorReactVersion, roomId)
-    );
-    deprecateIf(
-      !oldReactVersion && props.unstable_batchedUpdates !== void 0,
-      superfluous_unstable_batchedUpdates
+      majorReactVersion < requiredVersion,
+      `React ${requiredVersion} or higher is required (you\u2019re on ${reactVersion})`
     );
   }
   const frozenProps = useInitial({
     initialPresence: props.initialPresence,
     initialStorage: props.initialStorage,
-    unstable_batchedUpdates: props.unstable_batchedUpdates,
     autoConnect: props.autoConnect ?? typeof window !== "undefined"
   });
-  const [{ room }, setRoomLeavePair] = React4.useState(
+  const [{ room }, setRoomLeavePair] = useState2(
     () => stableEnterRoom(roomId, {
       ...frozenProps,
       autoConnect: false
       // Deliberately using false here on the first render, see below
     })
   );
-  React4.useEffect(() => {
+  useEffect5(() => {
     const { store } = getRoomExtrasForClient(client);
     async function handleCommentEvent(message) {
       if (message.type === ServerMsgCode.THREAD_DELETED) {
@@ -2685,7 +2852,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 ServerMsgCode.COMMENT_EDITED:
         case ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -2707,7 +2874,7 @@ function RoomProviderInner(props) {
       (message) => void handleCommentEvent(message)
     );
   }, [client, room]);
-  React4.useEffect(() => {
+  useEffect5(() => {
     const pair = stableEnterRoom(roomId, frozenProps);
     setRoomLeavePair(pair);
     const { room: room2, leave } = pair;
@@ -2718,7 +2885,7 @@ function RoomProviderInner(props) {
       leave();
     };
   }, [roomId, frozenProps, stableEnterRoom]);
-  return /* @__PURE__ */ React4.createElement(RoomContext.Provider, { value: room }, props.children);
+  return /* @__PURE__ */ jsx2(RoomContext.Provider, { value: room, children: props.children });
 }
 function useRoom() {
   const room = useRoomOrNull();
@@ -2732,12 +2899,12 @@ function useStatus() {
   const subscribe = room.events.status.subscribe;
   const getSnapshot = room.getStatus;
   const getServerSnapshot = room.getStatus;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot);
 }
 function useReportTextEditor(editor, rootKey) {
-  const isReported = React4.useRef(false);
+  const isReported = useRef3(false);
   const room = useRoom();
-  React4.useEffect(() => {
+  useEffect5(() => {
     if (isReported.current) {
       return;
     }
@@ -2750,6 +2917,52 @@ function useReportTextEditor(editor, rootKey) {
     return unsubscribe;
   }, [room, editor, rootKey]);
 }
+function useYjsProvider() {
+  const room = useRoom();
+  const subscribe = useCallback3(
+    (onStoreChange) => {
+      return room[kInternal3].yjsProviderDidChange.subscribe(onStoreChange);
+    },
+    [room]
+  );
+  const getSnapshot = useCallback3(() => {
+    return room[kInternal3].getYjsProvider();
+  }, [room]);
+  return useSyncExternalStore3(subscribe, getSnapshot, getSnapshot);
+}
+function useCreateTextMention() {
+  const room = useRoom();
+  return useCallback3(
+    (userId, mentionId) => {
+      room[kInternal3].createTextMention(userId, mentionId).catch((err) => {
+        console3.error(
+          `Cannot create text mention for user '${userId}' and mention '${mentionId}'`,
+          err
+        );
+      });
+    },
+    [room]
+  );
+}
+function useDeleteTextMention() {
+  const room = useRoom();
+  return useCallback3(
+    (mentionId) => {
+      room[kInternal3].deleteTextMention(mentionId).catch((err) => {
+        console3.error(`Cannot delete text mention '${mentionId}'`, err);
+      });
+    },
+    [room]
+  );
+}
+function useResolveMentionSuggestions() {
+  const client = useClient();
+  return client[kInternal3].resolveMentionSuggestions;
+}
+function useMentionSuggestionsCache() {
+  const client = useClient();
+  return client[kInternal3].mentionSuggestionsCache;
+}
 function useStorageStatus(options) {
   const smooth = useInitial(options?.smooth ?? false);
   if (smooth) {
@@ -2763,13 +2976,13 @@ function useStorageStatusImmediate() {
   const subscribe = room.events.storageStatus.subscribe;
   const getSnapshot = room.getStorageStatus;
   const getServerSnapshot = room.getStorageStatus;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot);
 }
 function useStorageStatusSmooth() {
   const room = useRoom();
-  const [status, setStatus] = React4.useState(room.getStorageStatus);
+  const [status, setStatus] = useState2(room.getStorageStatus);
   const oldStatus = useLatest(room.getStorageStatus());
-  React4.useEffect(() => {
+  useEffect5(() => {
     let timeoutId;
     const unsub = room.events.storageStatus.subscribe((newStatus) => {
       if (oldStatus.current === "synchronizing" && newStatus === "synchronized") {
@@ -2791,7 +3004,7 @@ function useBatch() {
 }
 function useBroadcastEvent() {
   const room = useRoom();
-  return React4.useCallback(
+  return useCallback3(
     (event, options = { shouldQueueEventIfNotReady: false }) => {
       room.broadcastEvent(event, options);
     },
@@ -2801,7 +3014,7 @@ function useBroadcastEvent() {
 function useOthersListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  useEffect5(
     () => room.events.others.subscribe((event) => savedCallback.current(event)),
     [room, savedCallback]
   );
@@ -2809,7 +3022,7 @@ function useOthersListener(callback) {
 function useLostConnectionListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  useEffect5(
     () => room.events.lostConnection.subscribe(
       (event) => savedCallback.current(event)
     ),
@@ -2819,7 +3032,7 @@ function useLostConnectionListener(callback) {
 function useErrorListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  useEffect5(
     () => room.events.error.subscribe((e) => savedCallback.current(e)),
     [room, savedCallback]
   );
@@ -2827,7 +3040,7 @@ function useErrorListener(callback) {
 function useEventListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(() => {
+  useEffect5(() => {
     const listener = (eventData) => {
       savedCallback.current(eventData);
     };
@@ -2847,25 +3060,25 @@ function useCanUndo() {
   const room = useRoom();
   const subscribe = room.events.history.subscribe;
   const canUndo = room.history.canUndo;
-  return useSyncExternalStore2(subscribe, canUndo, canUndo);
+  return useSyncExternalStore3(subscribe, canUndo, canUndo);
 }
 function useCanRedo() {
   const room = useRoom();
   const subscribe = room.events.history.subscribe;
   const canRedo = room.history.canRedo;
-  return useSyncExternalStore2(subscribe, canRedo, canRedo);
+  return useSyncExternalStore3(subscribe, canRedo, canRedo);
 }
 function useSelf(maybeSelector, isEqual) {
   const room = useRoom();
   const subscribe = room.events.self.subscribe;
   const getSnapshot = room.getSelf;
-  const selector = maybeSelector ?? identity2;
-  const wrappedSelector = React4.useCallback(
+  const selector = maybeSelector ?? identity3;
+  const wrappedSelector = useCallback3(
     (me) => me !== null ? selector(me) : null,
     [selector]
   );
   const getServerSnapshot = alwaysNull;
-  return useSyncExternalStoreWithSelector2(
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
@@ -2877,7 +3090,7 @@ function useMyPresence() {
   const room = useRoom();
   const subscribe = room.events.myPresence.subscribe;
   const getSnapshot = room.getPresence;
-  const presence = useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+  const presence = useSyncExternalStore3(subscribe, getSnapshot, getSnapshot);
   const setPresence = room.updatePresence;
   return [presence, setPresence];
 }
@@ -2889,20 +3102,20 @@ function useOthers(selector, isEqual) {
   const subscribe = room.events.others.subscribe;
   const getSnapshot = room.getOthers;
   const getServerSnapshot = alwaysEmptyList;
-  return useSyncExternalStoreWithSelector2(
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
-    selector ?? identity2,
+    selector ?? identity3,
     isEqual
   );
 }
 function useOthersMapped(itemSelector, itemIsEqual) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = useCallback3(
     (others) => others.map((other) => [other.connectionId, itemSelector(other)]),
     [itemSelector]
   );
-  const wrappedIsEqual = React4.useCallback(
+  const wrappedIsEqual = useCallback3(
     (a, b) => {
       const eq = itemIsEqual ?? Object.is;
       return a.length === b.length && a.every((atuple, index) => {
@@ -2919,14 +3132,14 @@ function useOthersConnectionIds() {
 }
 var NOT_FOUND = Symbol();
 function useOther(connectionId, selector, isEqual) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = useCallback3(
     (others) => {
       const other2 = others.find((other3) => other3.connectionId === connectionId);
       return other2 !== void 0 ? selector(other2) : NOT_FOUND;
     },
     [connectionId, selector]
   );
-  const wrappedIsEqual = React4.useCallback(
+  const wrappedIsEqual = useCallback3(
     (prev, curr) => {
       if (prev === NOT_FOUND || curr === NOT_FOUND) {
         return prev === curr;
@@ -2949,7 +3162,7 @@ function useMutableStorageRoot() {
   const subscribe = room.events.storageDidLoad.subscribeOnce;
   const getSnapshot = room.getStorageSnapshot;
   const getServerSnapshot = alwaysNull;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot);
 }
 function useStorageRoot() {
   return [useMutableStorageRoot()];
@@ -2957,15 +3170,15 @@ function useStorageRoot() {
 function useStorage(selector, isEqual) {
   const room = useRoom();
   const rootOrNull = useMutableStorageRoot();
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = useCallback3(
     (rootOrNull2) => rootOrNull2 !== null ? selector(rootOrNull2) : null,
     [selector]
   );
-  const subscribe = React4.useCallback(
+  const subscribe = useCallback3(
     (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop3,
     [room, rootOrNull]
   );
-  const getSnapshot = React4.useCallback(() => {
+  const getSnapshot = useCallback3(() => {
     if (rootOrNull === null) {
       return null;
     } else {
@@ -2975,7 +3188,7 @@ function useStorage(selector, isEqual) {
     }
   }, [rootOrNull]);
   const getServerSnapshot = alwaysNull;
-  return useSyncExternalStoreWithSelector2(
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
@@ -2985,7 +3198,7 @@ function useStorage(selector, isEqual) {
 }
 function useMutation(callback, deps) {
   const room = useRoom();
-  return React4.useMemo(
+  return useMemo3(
     () => {
       return (...args) => (
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -3012,7 +3225,7 @@ function useThreads(options = {
   const room = useRoom();
   const { store, getOrCreateThreadsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateThreadsPollerForRoomId(room.id);
-  React4.useEffect(
+  useEffect5(
     () => {
       void store.waitUntilRoomThreadsLoaded(room.id, options.query);
     }
@@ -3025,20 +3238,20 @@ function useThreads(options = {
     // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
     //    *next* render after that, a *new* fetch/promise will get created.
   );
-  React4.useEffect(() => {
+  useEffect5(() => {
     poller.inc();
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = useCallback3(
     () => store.getRoomThreadsLoadingState(room.id, options.query),
     [store, room.id, options.query]
   );
-  const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
+  const state = useSyncExternalStoreWithSelector(
+    store.subscribe1_threads,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
     // NOTE: Using 2-level-deep shallow check here, because the result of selectThreads() is not stable!
   );
@@ -3049,7 +3262,7 @@ function useCommentsErrorListener(callback) {
   const client = useClient();
   const savedCallback = useLatest(callback);
   const { commentsErrorEventSource } = getRoomExtrasForClient(client);
-  React4.useEffect(() => {
+  useEffect5(() => {
     return commentsErrorEventSource.subscribe(savedCallback.current);
   }, [savedCallback, commentsErrorEventSource]);
 }
@@ -3058,7 +3271,7 @@ function useCreateThread() {
 }
 function useCreateRoomThread(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (options) => {
       const body = options.body;
       const metadata = options.metadata ?? {};
@@ -3127,11 +3340,11 @@ function useDeleteThread() {
 }
 function useDeleteRoomThread(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (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 (existing?.comments?.[0]?.userId !== userId) {
         throw new Error("Only the thread creator can delete the thread");
       }
@@ -3160,7 +3373,7 @@ function useEditThreadMetadata() {
 }
 function useEditRoomThreadMetadata(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (options) => {
       if (!options.metadata) {
         return;
@@ -3204,7 +3417,7 @@ function useCreateComment() {
 }
 function useCreateRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     ({ threadId, body, attachments }) => {
       const commentId = createCommentId();
       const createdAt = /* @__PURE__ */ new Date();
@@ -3250,11 +3463,11 @@ function useEditComment() {
 }
 function useEditRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     ({ 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) {
         console3.warn(
           `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
@@ -3304,7 +3517,7 @@ function useDeleteComment() {
 }
 function useDeleteRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     ({ threadId, commentId }) => {
       const deletedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
@@ -3343,7 +3556,7 @@ function useAddReaction() {
 }
 function useAddRoomCommentReaction(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     ({ threadId, commentId, emoji }) => {
       const createdAt = /* @__PURE__ */ new Date();
       const userId = getCurrentUserId(client);
@@ -3388,7 +3601,7 @@ function useRemoveReaction() {
 }
 function useRemoveRoomCommentReaction(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     ({ threadId, commentId, emoji }) => {
       const userId = getCurrentUserId(client);
       const removedAt = /* @__PURE__ */ new Date();
@@ -3432,11 +3645,11 @@ function useMarkThreadAsRead() {
 }
 function useMarkRoomThreadAsRead(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (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
       );
@@ -3478,7 +3691,7 @@ function useMarkThreadAsResolved() {
 }
 function useMarkRoomThreadAsResolved(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
@@ -3514,7 +3727,7 @@ function useMarkThreadAsUnresolved() {
 }
 function useMarkRoomThreadAsUnresolved(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return useCallback3(
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
@@ -3548,9 +3761,10 @@ function useMarkRoomThreadAsUnresolved(roomId) {
 function useThreadSubscription(threadId) {
   const client = useClient();
   const { store } = getRoomExtrasForClient(client);
-  const selector = React4.useCallback(
+  const signal = store.outputs.threadifications;
+  const selector = useCallback3(
     (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 +3778,7 @@ function useThreadSubscription(threadId) {
     },
     [threadId]
   );
-  return useSyncExternalStoreWithSelector2(
-    store.subscribe,
-    store.getFullState,
-    store.getFullState,
-    selector
-  );
+  return useSignal(signal, selector, shallow4);
 }
 function useRoomNotificationSettings() {
   const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
@@ -3577,7 +3786,7 @@ function useRoomNotificationSettings() {
   const room = useRoom();
   const { store, getOrCreateNotificationsSettingsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateNotificationsSettingsPollerForRoomId(room.id);
-  React4.useEffect(
+  useEffect5(
     () => {
       void store.waitUntilRoomNotificationSettingsLoaded(room.id);
     }
@@ -3590,25 +3799,25 @@ function useRoomNotificationSettings() {
     // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
     //    *next* render after that, a *new* fetch/promise will get created.
   );
-  React4.useEffect(() => {
+  useEffect5(() => {
     poller.inc();
     poller.pollNowIfStale();
     return () => {
       poller.dec();
     };
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = useCallback3(
     () => store.getNotificationSettingsLoadingState(room.id),
     [store, room.id]
   );
-  const settings = useSyncExternalStoreWithSelector2(
-    store.subscribe,
+  const settings = useSyncExternalStoreWithSelector(
+    store.subscribe2,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
-  return React4.useMemo(() => {
+  return useMemo3(() => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
@@ -3620,16 +3829,16 @@ function useRoomNotificationSettingsSuspense() {
   const [settings, updateRoomNotificationSettings] = useRoomNotificationSettings();
   assert2(!settings.error, "Did not expect error");
   assert2(!settings.isLoading, "Did not expect loading");
-  return React4.useMemo(() => {
+  return useMemo3(() => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
 function useHistoryVersionData(versionId) {
-  const [state, setState] = React4.useState({
+  const [state, setState] = useState2({
     isLoading: true
   });
   const room = useRoom();
-  React4.useEffect(() => {
+  useEffect5(() => {
     setState({ isLoading: true });
     const load = async () => {
       try {
@@ -3658,16 +3867,16 @@ function useHistoryVersions() {
   const room = useRoom();
   const { store, getOrCreateVersionsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateVersionsPollerForRoomId(room.id);
-  React4.useEffect(() => {
+  useEffect5(() => {
     poller.inc();
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = useCallback3(
     () => store.getRoomVersionsLoadingState(room.id),
     [store, room.id]
   );
-  React4.useEffect(
+  useEffect5(
     () => {
       void store.waitUntilRoomVersionsLoaded(room.id);
     }
@@ -3680,11 +3889,11 @@ function useHistoryVersions() {
     // 3. If ever the promise would fail, then after 5 seconds it would reset, and on the very
     //    *next* render after that, a *new* fetch/promise will get created.
   );
-  const state = useSyncExternalStoreWithSelector2(
-    store.subscribe,
+  const state = useSyncExternalStoreWithSelector(
+    store.subscribe3,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
   return state;
@@ -3702,7 +3911,7 @@ function useHistoryVersionsSuspense() {
 function useUpdateRoomNotificationSettings() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return useCallback3(
     (settings) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
       const optimisticUpdateId = store.addOptimisticUpdate({
@@ -3816,14 +4025,14 @@ function useAttachmentUrl(attachmentId) {
 function useRoomAttachmentUrl(attachmentId, roomId) {
   const client = useClient();
   const store = client[kInternal3].httpClient.getOrCreateAttachmentUrlsStore(roomId);
-  const getAttachmentUrlState = React4.useCallback(
+  const getAttachmentUrlState = useCallback3(
     () => store.getState(attachmentId),
     [store, attachmentId]
   );
-  React4.useEffect(() => {
+  useEffect5(() => {
     void store.get(attachmentId);
   }, [store, attachmentId]);
-  return useSyncExternalStoreWithSelector2(
+  return useSyncExternalStoreWithSelector(
     store.subscribe,
     getAttachmentUrlState,
     getAttachmentUrlState,
@@ -3834,7 +4043,7 @@ function useRoomAttachmentUrl(attachmentId, roomId) {
 function useAttachmentUrlSuspense(attachmentId) {
   const room = useRoom();
   const { attachmentUrlsStore } = room[kInternal3];
-  const getAttachmentUrlState = React4.useCallback(
+  const getAttachmentUrlState = useCallback3(
     () => attachmentUrlsStore.getState(attachmentId),
     [attachmentUrlsStore, attachmentId]
   );
@@ -3845,7 +4054,7 @@ function useAttachmentUrlSuspense(attachmentId) {
   if (attachmentUrlState.error) {
     throw attachmentUrlState.error;
   }
-  const state = useSyncExternalStore2(
+  const state = useSyncExternalStore3(
     attachmentUrlsStore.subscribe,
     getAttachmentUrlState,
     getAttachmentUrlState
@@ -3862,11 +4071,10 @@ function useAttachmentUrlSuspense(attachmentId) {
 function useRoomPermissions(roomId) {
   const client = useClient();
   const store = getRoomExtrasForClient(client).store;
-  return 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) => hints[roomId] ?? /* @__PURE__ */ new Set()
+  );
 }
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
@@ -3913,6 +4121,7 @@ var _useUpdateMyPresence = useUpdateMyPresence;
 export {
   RoomContext,
   useRoomOrNull,
+  useSyncExternalStoreWithSelector,
   ClientContext,
   getUmbrellaStoreForClient,
   useClientOrNull,
@@ -3936,8 +4145,14 @@ export {
   _useUserThreadsSuspense_experimental,
   useSyncStatus,
   CreateThreadError,
+  useSignal,
   useStatus,
   useReportTextEditor,
+  useYjsProvider,
+  useCreateTextMention,
+  useDeleteTextMention,
+  useResolveMentionSuggestions,
+  useMentionSuggestionsCache,
   useStorageStatus,
   useBatch,
   useLostConnectionListener,
@@ -4008,4 +4223,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-BRCWZCNY.mjs.map
+//# sourceMappingURL=chunk-UJLD6FYC.mjs.map