@liveblocks/react 2.14.0 → 2.15.0

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

@@ -1,14 +1,90 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/contexts.ts
-var _react = require('react'); var React = _interopRequireWildcard(_react); var React4 = _interopRequireWildcard(_react); var React3 = _interopRequireWildcard(_react);
-var RoomContext = React.createContext(null);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/contexts.ts
+var _react = require('react');
+var RoomContext = _react.createContext.call(void 0, null);
 function useRoomOrNull() {
-  return React.useContext(RoomContext);
+  return _react.useContext.call(void 0, RoomContext);
 }
 function useIsInsideRoom() {
   const room = useRoomOrNull();
   return room !== null;
 }
 
+// src/use-sync-external-store-with-selector.ts
+
+
+
+
+
+
+
+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 = _react.useRef.call(void 0, null);
+  let inst;
+  if (instRef.current === null) {
+    inst = {
+      hasValue: false,
+      value: null
+    };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+  const [getSelection, getServerSelection] = _react.useMemo.call(void 0, () => {
+    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 = _react.useSyncExternalStore.call(void 0, 
+    subscribe,
+    getSelection,
+    getServerSelection
+  );
+  _react.useEffect.call(void 0, () => {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [value]);
+  _react.useDebugValue.call(void 0, value);
+  return value;
+}
+
 // src/liveblocks.tsx
 
 
@@ -25,8 +101,8 @@ var _core = require('@liveblocks/core');
 
 
 
-var _indexjs = require('use-sync-external-store/shim/index.js');
-var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');
+
+
 
 // src/config.ts
 var SECONDS = 1e3;
@@ -132,6 +208,8 @@ var use = (
 
 
 
+
+
 // src/lib/autobind.ts
 function autobind(self) {
   const seen = /* @__PURE__ */ new Set();
@@ -149,6 +227,14 @@ function autobind(self) {
   } while ((obj = Reflect.getPrototypeOf(obj)) && obj !== Object.prototype);
 }
 
+// src/lib/itertools.ts
+function find(it, predicate) {
+  for (const item of it) {
+    if (predicate(item)) return item;
+  }
+  return void 0;
+}
+
 // src/ThreadDB.ts
 
 
@@ -202,36 +288,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 +324,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
@@ -267,12 +354,24 @@ var ThreadDB = class _ThreadDB {
       this.upsert(thread);
     }
   }
+  applyDelta(updates) {
+    _core.batch.call(void 0, () => {
+      for (const thread of updates.newThreads) {
+        this.upsertIfNewer(thread);
+      }
+      for (const { id, deletedAt } of updates.deletedThreads) {
+        const existing = this.getEvenIfDeleted(id);
+        if (!existing) continue;
+        this.delete(id, deletedAt);
+      }
+    });
+  }
   /**
    * Marks a thread as deleted. It will no longer pop up in .findMany()
    * queries, but it can still be accessed via `.getEvenIfDeleted()`.
    */
   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 +388,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 +396,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 +432,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 +503,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 +518,7 @@ var PaginatedResource = class {
     );
     const promise = usify(
       initialFetcher.then((cursor) => {
-        this._paginationState = {
+        this.#paginationState = {
           cursor,
           isFetchingMore: false,
           fetchMoreError: void 0
@@ -427,129 +526,375 @@ 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;
-    }
-    if (usable.status === "rejected") {
+    } else if (usable.status === "rejected") {
       return { isLoading: false, error: usable.reason };
+    } else {
+      return { isLoading: false, data: void 0 };
     }
-    return {
-      isLoading: false,
-      data: void 0
-    };
   }
+  #cachedPromise = null;
   waitUntilLoaded() {
-    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;
   }
 };
+function createStore_forNotifications() {
+  const signal = new (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
+  function markRead(notificationId, readAt) {
+    signal.mutate((lut) => {
+      const existing = lut.get(notificationId);
+      if (!existing) {
+        return false;
+      }
+      lut.set(notificationId, { ...existing, readAt });
+      return true;
+    });
+  }
+  function markAllRead(readAt) {
+    return signal.mutate((lut) => {
+      for (const n of lut.values()) {
+        n.readAt = readAt;
+      }
+    });
+  }
+  function deleteOne(inboxNotificationId) {
+    signal.mutate((lut) => lut.delete(inboxNotificationId));
+  }
+  function clear() {
+    signal.mutate((lut) => lut.clear());
+  }
+  function applyDelta(newInboxNotifications, deletedNotifications) {
+    signal.mutate((lut) => {
+      let mutated = false;
+      for (const n of newInboxNotifications) {
+        const existing = lut.get(n.id);
+        if (existing) {
+          const result = compareInboxNotifications(existing, n);
+          if (result === 1) continue;
+        }
+        lut.set(n.id, n);
+        mutated = true;
+      }
+      for (const n of deletedNotifications) {
+        lut.delete(n.id);
+        mutated = true;
+      }
+      return mutated;
+    });
+  }
+  function updateAssociatedNotification(newComment) {
+    signal.mutate((lut) => {
+      const existing = find(
+        lut.values(),
+        (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
+      );
+      if (!existing) return false;
+      lut.set(existing.id, {
+        ...existing,
+        notifiedAt: newComment.createdAt,
+        readAt: newComment.createdAt
+      });
+      return true;
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    markAllRead,
+    markRead,
+    delete: deleteOne,
+    applyDelta,
+    clear,
+    updateAssociatedNotification,
+    // XXX_vincent Remove this eventually
+    force_set: (mutationCallback) => signal.mutate(mutationCallback),
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forRoomNotificationSettings() {
+  const signal = new (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
+  function update(roomId, settings) {
+    signal.mutate((lut) => {
+      lut.set(roomId, settings);
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    update,
+    // XXX_vincent Remove this eventually
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forHistoryVersions() {
+  const signal = new (0, _core.MutableSignal)(/* @__PURE__ */ new Map());
+  function update(roomId, versions) {
+    signal.mutate((lut) => {
+      const versionsById = _nullishCoalesce(lut.get(roomId), () => ( (lut.set(roomId, /* @__PURE__ */ new Map()), lut.get(roomId))));
+      for (const version of versions) {
+        versionsById.set(version.id, version);
+      }
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    update,
+    // XXX_vincent Remove these eventually
+    force_set: (callback) => signal.mutate(callback),
+    invalidate: () => signal.mutate()
+  };
+}
+function createStore_forPermissionHints() {
+  const signal = new (0, _core.Signal)({});
+  function update(newHints) {
+    signal.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;
+    });
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    update,
+    // XXX_vincent Remove this eventually
+    invalidate: () => signal.set((store) => ({ ...store }))
+  };
+}
+function createStore_forOptimistic(client) {
+  const signal = new (0, _core.Signal)([]);
+  const syncSource = client[_core.kInternal].createSyncSource();
+  signal.subscribe(
+    () => syncSource.setSyncStatus(
+      signal.get().length > 0 ? "synchronizing" : "synchronized"
+    )
+  );
+  function add(optimisticUpdate) {
+    const id = _core.nanoid.call(void 0, );
+    const newUpdate = { ...optimisticUpdate, id };
+    signal.set((state) => [...state, newUpdate]);
+    return id;
+  }
+  function remove(optimisticId) {
+    signal.set((state) => state.filter((ou) => ou.id !== optimisticId));
+  }
+  return {
+    signal: signal.asReadonly(),
+    // Mutations
+    add,
+    remove,
+    // XXX_vincent Remove this eventually
+    invalidate: () => signal.set((store) => [...store])
+  };
+}
 var UmbrellaStore = class {
+  #client;
+  //
+  // 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.)
+  //
+  // XXX_vincent Now that we have createStore_forX, we should probably also change
+  // `threads` to this pattern, ie create a createStore_forThreads helper as
+  // well. It almost works like that already anyway!
+  
+  // Exposes its signal under `.signal` prop
+  
+  
+  // prettier-ignore
+  
+  
+  
+  //
+  // 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.
+  //
+  // XXX_vincent APIs like getRoomThreadsLoadingState should really also be modeled as output signals.
+  //
+  
+  // Notifications
+  #notificationsLastRequestedAt = null;
+  // Keeps track of when we successfully requested an inbox notifications update for the last time. Will be `null` as long as the first successful fetch hasn't happened yet.
+  #notifications;
+  // 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.optimisticUpdates = createStore_forOptimistic(this.#client);
+    this.permissionHints = createStore_forPermissionHints();
     const inboxFetcher = async (cursor) => {
-      const result = await this._client.getInboxNotifications({ cursor });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
-      if (this._notificationsLastRequestedAt === null) {
-        this._notificationsLastRequestedAt = result.requestedAt;
+      const result = await this.#client.getInboxNotifications({ cursor });
+      this.updateThreadifications(result.threads, result.inboxNotifications);
+      if (this.#notificationsLastRequestedAt === null) {
+        this.#notificationsLastRequestedAt = result.requestedAt;
       }
       const nextCursor = result.nextCursor;
       return nextCursor;
     };
-    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._rawThreadsDB = new ThreadDB();
-    this._store = _core.createStore.call(void 0, {
-      optimisticUpdates: [],
-      permissionsByRoom: {},
-      notificationsById: {},
-      settingsByRoomId: {},
-      versionsByRoomId: {}
-    });
+    this.threads = new ThreadDB();
+    this.notifications = createStore_forNotifications();
+    this.roomNotificationSettings = createStore_forRoomNotificationSettings();
+    this.historyVersions = createStore_forHistoryVersions();
+    const threadifications = _core.DerivedSignal.from(
+      this.threads.signal,
+      this.notifications.signal,
+      this.optimisticUpdates.signal,
+      (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.roomNotificationSettings.signal,
+      this.optimisticUpdates.signal,
+      (settings, updates) => applyOptimisticUpdates_forSettings(settings, updates)
+    );
+    const versionsByRoomId = _core.DerivedSignal.from(
+      this.historyVersions.signal,
+      (hv) => Object.fromEntries(
+        [...hv].map(([roomId, versions]) => [
+          roomId,
+          Object.fromEntries(versions)
+        ])
+      )
+    );
+    this.outputs = {
+      threadifications,
+      threads,
+      notifications,
+      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);
+  }
+  get1_threads() {
+    return this.outputs.threads.get();
+  }
+  subscribe1_threads(callback) {
+    return this.outputs.threads.subscribe(callback);
   }
-  batch(callback) {
-    return this._store.batch(callback);
+  get1_notifications() {
+    return this.outputs.notifications.get();
   }
-  getFullState() {
-    return this.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 +903,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 +911,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 +928,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 +936,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 +954,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 +969,10 @@ var UmbrellaStore = class {
     };
   }
   // NOTE: This will read the async result, but WILL NOT start loading at the moment!
+  // XXX_vincent This should really be a derived Signal!
   getNotificationSettingsLoadingState(roomId) {
     const queryKey = makeNotificationSettingsQueryKey(roomId);
-    const resource = this._roomNotificationSettings.get(queryKey);
+    const resource = this.#roomNotificationSettings.get(queryKey);
     if (resource === void 0) {
       return ASYNC_LOADING;
     }
@@ -636,12 +982,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,134 +997,68 @@ 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;
-    });
-  }
-  setNotificationSettings(roomId, settings) {
-    this._store.set((state) => ({
-      ...state,
-      settingsByRoomId: {
-        ...state.settingsByRoomId,
-        [roomId]: settings
-      }
-    }));
-  }
-  updateRoomVersions(roomId, versions) {
-    this._store.set((state) => {
-      const versionsById = Object.fromEntries(
-        versions.map((version2) => [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
-          }
-        }
-      };
-    });
-  }
-  updateOptimisticUpdatesCache(mapFn) {
-    this._store.set((state) => {
-      const optimisticUpdates = mapFn(state.optimisticUpdates);
-      this._syncSource.setSyncStatus(
-        optimisticUpdates.length > 0 ? "synchronizing" : "synchronized"
-      );
-      return { ...state, optimisticUpdates };
+  /** @internal - Only call this method from unit tests. */
+  force_set_versions(callback) {
+    _core.batch.call(void 0, () => {
+      this.historyVersions.force_set(callback);
+      this.invalidateEntireStore();
     });
   }
-  // ---------------------------------------------------------------------------------- }}}
   /** @internal - Only call this method from unit tests. */
-  force_set(callback) {
-    return this._store.set(callback);
+  force_set_notifications(callback) {
+    _core.batch.call(void 0, () => {
+      this.notifications.force_set(callback);
+      this.invalidateEntireStore();
+    });
   }
   /**
    * Updates an existing inbox notification with a new value, replacing the
    * corresponding optimistic update.
    *
-   * This will not update anything if the inbox notification ID isn't found in
-   * the cache.
+   * This will not update anything if the inbox notification ID isn't found.
    */
-  updateInboxNotification(inboxNotificationId, optimisticUpdateId, callback) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => {
-        const existing = cache[inboxNotificationId];
-        if (!existing) {
-          return cache;
-        }
-        const inboxNotifications = {
-          ...cache,
-          [inboxNotificationId]: callback(existing)
-        };
-        return inboxNotifications;
-      });
+  markInboxNotificationRead(inboxNotificationId, readAt, optimisticId) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.markRead(inboxNotificationId, readAt);
     });
   }
-  /**
-   * Updates *all* inbox notifications by running a mapper function over all of
-   * them, replacing the corresponding optimistic update.
-   */
-  updateAllInboxNotifications(optimisticUpdateId, mapFn) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => _core.mapValues.call(void 0, cache, mapFn));
+  markAllInboxNotificationsRead(optimisticId, readAt) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.markAllRead(readAt);
     });
   }
   /**
    * Deletes an existing inbox notification, replacing the corresponding
    * optimistic update.
    */
-  deleteInboxNotification(inboxNotificationId, optimisticUpdateId) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache((cache) => {
-        const { [inboxNotificationId]: removed, ...newCache } = cache;
-        return removed === void 0 ? cache : newCache;
-      });
+  deleteInboxNotification(inboxNotificationId, optimisticId) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.delete(inboxNotificationId);
     });
   }
   /**
    * Deletes *all* inbox notifications, replacing the corresponding optimistic
    * update.
    */
-  deleteAllInboxNotifications(optimisticUpdateId) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.updateInboxNotificationsCache(() => ({}));
+  deleteAllInboxNotifications(optimisticId) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.notifications.clear();
     });
   }
   /**
    * Creates an new thread, replacing the corresponding optimistic update.
    */
-  createThread(optimisticUpdateId, thread) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.mutateThreadsDB((db) => db.upsert(thread));
+  createThread(optimisticId, thread) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.threads.upsert(thread);
     });
   }
   /**
@@ -786,44 +1066,43 @@ var UmbrellaStore = class {
    * optimistic update.
    *
    * This will not update anything if:
-   * - The thread ID isn't found in the cache; or
-   * - The thread ID was already deleted from the cache; or
-   * - The thread ID in the cache was updated more recently than the optimistic
-   *   update's timestamp (if given)
+   * - The thread ID isn't found; or
+   * - The thread ID was already deleted; or
+   * - The thread ID was updated more recently than the optimistic update's
+   *   timestamp (if given)
    */
-  updateThread(threadId, optimisticUpdateId, callback, updatedAt) {
-    this._store.batch(() => {
-      if (optimisticUpdateId !== null) {
-        this.removeOptimisticUpdate(optimisticUpdateId);
+  #updateThread(threadId, optimisticId, callback, updatedAt) {
+    _core.batch.call(void 0, () => {
+      if (optimisticId !== null) {
+        this.optimisticUpdates.remove(optimisticId);
       }
-      this.mutateThreadsDB((db) => {
-        const existing = db.get(threadId);
-        if (!existing) return;
-        if (!!updatedAt && existing.updatedAt > updatedAt) return;
-        db.upsert(callback(existing));
-      });
+      const db = this.threads;
+      const existing = db.get(threadId);
+      if (!existing) return;
+      if (!!updatedAt && existing.updatedAt > updatedAt) return;
+      db.upsert(callback(existing));
     });
   }
-  patchThread(threadId, optimisticUpdateId, patch, updatedAt) {
-    return this.updateThread(
+  patchThread(threadId, optimisticId, patch, updatedAt) {
+    return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => ({ ...thread, ..._core.compactObject.call(void 0, patch) }),
       updatedAt
     );
   }
-  addReaction(threadId, optimisticUpdateId, commentId, reaction, createdAt) {
-    this.updateThread(
+  addReaction(threadId, optimisticId, commentId, reaction, createdAt) {
+    this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyAddReaction(thread, commentId, reaction),
       createdAt
     );
   }
-  removeReaction(threadId, optimisticUpdateId, commentId, emoji, userId, removedAt) {
-    this.updateThread(
+  removeReaction(threadId, optimisticId, commentId, emoji, userId, removedAt) {
+    this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyRemoveReaction(thread, commentId, emoji, userId, removedAt),
       removedAt
     );
@@ -833,13 +1112,13 @@ var UmbrellaStore = class {
    * replacing the corresponding optimistic update.
    *
    * This will not update anything if:
-   * - The thread ID isn't found in the cache; or
-   * - The thread ID was already deleted from the cache
+   * - The thread ID isn't found; or
+   * - The thread ID was already deleted
    */
-  deleteThread(threadId, optimisticUpdateId) {
-    return this.updateThread(
+  deleteThread(threadId, optimisticId) {
+    return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       // A deletion is actually an update of the deletedAt property internally
       (thread) => ({ ...thread, updatedAt: /* @__PURE__ */ new Date(), deletedAt: /* @__PURE__ */ new Date() })
     );
@@ -848,107 +1127,61 @@ var UmbrellaStore = class {
    * Creates an existing comment and ensures the associated notification is
    * updated correctly, replacing the corresponding optimistic update.
    */
-  createComment(newComment, optimisticUpdateId) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      const existingThread = this._rawThreadsDB.get(newComment.threadId);
+  createComment(newComment, optimisticId) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      const existingThread = this.threads.get(newComment.threadId);
       if (!existingThread) {
         return;
       }
-      this.mutateThreadsDB(
-        (db) => db.upsert(applyUpsertComment(existingThread, newComment))
-      );
-      this.updateInboxNotificationsCache((cache) => {
-        const existingNotification = Object.values(cache).find(
-          (notification) => notification.kind === "thread" && notification.threadId === newComment.threadId
-        );
-        if (!existingNotification) {
-          return cache;
-        }
-        return {
-          ...cache,
-          [existingNotification.id]: {
-            ...existingNotification,
-            notifiedAt: newComment.createdAt,
-            readAt: newComment.createdAt
-          }
-        };
-      });
+      this.threads.upsert(applyUpsertComment(existingThread, newComment));
+      this.notifications.updateAssociatedNotification(newComment);
     });
   }
-  editComment(threadId, optimisticUpdateId, editedComment) {
-    return this.updateThread(
+  editComment(threadId, optimisticId, editedComment) {
+    return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyUpsertComment(thread, editedComment)
     );
   }
-  deleteComment(threadId, optimisticUpdateId, commentId, deletedAt) {
-    return this.updateThread(
+  deleteComment(threadId, optimisticId, commentId, deletedAt) {
+    return this.#updateThread(
       threadId,
-      optimisticUpdateId,
+      optimisticId,
       (thread) => applyDeleteComment(thread, commentId, deletedAt),
       deletedAt
     );
   }
-  updateThreadAndNotification(thread, inboxNotification) {
-    this._store.batch(() => {
-      this.mutateThreadsDB((db) => db.upsertIfNewer(thread));
-      if (inboxNotification !== void 0) {
-        this.updateInboxNotificationsCache((cache) => ({
-          ...cache,
-          [inboxNotification.id]: inboxNotification
-        }));
-      }
-    });
-  }
-  updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads = [], deletedInboxNotifications = []) {
-    this._store.batch(() => {
-      this.mutateThreadsDB(
-        (db) => applyThreadDeltaUpdates(db, { newThreads: threads, deletedThreads })
-      );
-      this.updateInboxNotificationsCache(
-        (cache) => applyNotificationsUpdates(cache, {
-          newInboxNotifications: inboxNotifications,
-          deletedNotifications: deletedInboxNotifications
-        })
-      );
+  updateThreadifications(threads, notifications, deletedThreads = [], deletedNotifications = []) {
+    _core.batch.call(void 0, () => {
+      this.threads.applyDelta({ newThreads: threads, deletedThreads });
+      this.notifications.applyDelta(notifications, deletedNotifications);
     });
   }
   /**
    * Updates existing notification setting for a room with a new value,
    * replacing the corresponding optimistic update.
    */
-  updateRoomNotificationSettings_confirmOptimisticUpdate(roomId, optimisticUpdateId, settings) {
-    this._store.batch(() => {
-      this.removeOptimisticUpdate(optimisticUpdateId);
-      this.setNotificationSettings(roomId, settings);
+  updateRoomNotificationSettings(roomId, optimisticId, settings) {
+    _core.batch.call(void 0, () => {
+      this.optimisticUpdates.remove(optimisticId);
+      this.roomNotificationSettings.update(roomId, settings);
     });
   }
-  addOptimisticUpdate(optimisticUpdate) {
-    const id = _core.nanoid.call(void 0, );
-    const newUpdate = { ...optimisticUpdate, id };
-    this.updateOptimisticUpdatesCache((cache) => [...cache, newUpdate]);
-    return id;
-  }
-  removeOptimisticUpdate(optimisticUpdateId) {
-    this.updateOptimisticUpdatesCache(
-      (cache) => cache.filter((ou) => ou.id !== optimisticUpdateId)
-    );
-  }
   async fetchNotificationsDeltaUpdate(signal) {
-    const lastRequestedAt = this._notificationsLastRequestedAt;
+    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(
+    this.updateThreadifications(
       result.threads.updated,
       result.inboxNotifications.updated,
       result.threads.deleted,
@@ -956,42 +1189,25 @@ 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;
-    });
-    this._store.set((state) => ({
-      ...state,
-      permissionsByRoom
-    }));
+    return this.#notifications.waitUntilLoaded();
   }
   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
       });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
-      this.updateRoomPermissions(result.permissionHints);
-      const lastRequestedAt = this._roomThreadsLastRequestedAtByRoom.get(roomId);
+      this.updateThreadifications(result.threads, result.inboxNotifications);
+      this.permissionHints.update(result.permissionHints);
+      const lastRequestedAt = this.#roomThreadsLastRequestedAtByRoom.get(roomId);
       if (lastRequestedAt === void 0 || lastRequestedAt > result.requestedAt) {
-        this._roomThreadsLastRequestedAtByRoom.set(roomId, result.requestedAt);
+        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,51 +1215,48 @@ 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
     });
-    this.updateThreadsAndNotifications(
+    this.updateThreadifications(
       updates.threads.updated,
       updates.inboxNotifications.updated,
       updates.threads.deleted,
       updates.inboxNotifications.deleted
     );
-    this.updateRoomPermissions(updates.permissionHints);
+    this.permissionHints.update(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
       });
-      this.updateThreadsAndNotifications(
-        result.threads,
-        result.inboxNotifications
-      );
-      this.updateRoomPermissions(result.permissionHints);
-      if (this._userThreadsLastRequestedAt === null) {
-        this._userThreadsLastRequestedAt = result.requestedAt;
+      this.updateThreadifications(result.threads, result.inboxNotifications);
+      this.permissionHints.update(result.permissionHints);
+      if (this.#userThreadsLastRequestedAt === null) {
+        this.#userThreadsLastRequestedAt = result.requestedAt;
       }
       return result.nextCursor;
     };
-    let paginatedResource = this._userThreads.get(queryKey);
+    let paginatedResource = this.#userThreads.get(queryKey);
     if (paginatedResource === void 0) {
       paginatedResource = new PaginatedResource(threadsFetcher);
     }
@@ -1051,38 +1264,49 @@ 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();
   }
+  // XXX_vincent We should really be going over all call sites, and replace this call
+  // with a more specific invalidation!
+  invalidateEntireStore() {
+    _core.batch.call(void 0, () => {
+      this.historyVersions.invalidate();
+      this.notifications.invalidate();
+      this.optimisticUpdates.invalidate();
+      this.permissionHints.invalidate();
+      this.roomNotificationSettings.invalidate();
+    });
+  }
   async fetchUserThreadsDeltaUpdate(signal) {
-    const lastRequestedAt = this._userThreadsLastRequestedAt;
+    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(
+    this.updateThreadifications(
       result.threads.updated,
       result.inboxNotifications.updated,
       result.threads.deleted,
       result.inboxNotifications.deleted
     );
-    this.updateRoomPermissions(result.permissionHints);
+    this.permissionHints.update(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 +1314,10 @@ var UmbrellaStore = class {
           );
         }
         const result = await room[_core.kInternal].listTextVersions();
-        this.updateRoomVersions(roomId, result.versions);
-        const lastRequestedAt = this._roomVersionsLastRequestedAtByRoom.get(roomId);
+        this.historyVersions.update(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 +1329,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.historyVersions.update(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 +1366,7 @@ var UmbrellaStore = class {
           );
         }
         const result = await room.getNotificationSettings();
-        this.setNotificationSettings(roomId, result);
+        this.roomNotificationSettings.update(roomId, result);
       };
       resource = new SinglePageResource(notificationSettingsFetcher);
     }
@@ -1150,28 +1374,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.roomNotificationSettings.update(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, notificationsLUT, optimisticUpdates) {
+  const threadsDB = baseThreadsDB.clone();
+  let notificationsById = Object.fromEntries(notificationsLUT);
+  for (const optimisticUpdate of optimisticUpdates) {
     switch (optimisticUpdate.type) {
       case "create-thread": {
         threadsDB.upsert(optimisticUpdate.thread);
@@ -1209,15 +1430,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 +1499,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,64 +1523,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;
       }
-      case "update-notification-settings": {
-        const settings = computed.settingsByRoomId[optimisticUpdate.roomId];
-        if (settings === void 0) {
-          break;
-        }
-        computed.settingsByRoomId[optimisticUpdate.roomId] = {
-          ...settings,
-          ...optimisticUpdate.settings
-        };
-      }
     }
   }
-  const cleanedNotifications = (
+  const sortedNotifications = (
     // Sort so that the most recent notifications are first
-    Object.values(computed.notificationsById).filter(
+    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 {
-    cleanedNotifications,
-    notificationsById: computed.notificationsById,
-    settingsByRoomId: computed.settingsByRoomId,
-    threadsDB,
-    versionsByRoomId: state.versionsByRoomId
+    sortedNotifications,
+    notificationsById,
+    threadsDB
   };
 }
-function applyThreadDeltaUpdates(db, updates) {
-  updates.newThreads.forEach((thread) => db.upsertIfNewer(thread));
-  updates.deletedThreads.forEach(({ id, deletedAt }) => {
-    const existing = db.getEvenIfDeleted(id);
-    if (!existing) return;
-    db.delete(id, deletedAt);
-  });
-}
-function applyNotificationsUpdates(existingInboxNotifications, updates) {
-  const updatedInboxNotifications = { ...existingInboxNotifications };
-  updates.newInboxNotifications.forEach((notification) => {
-    const existingNotification = updatedInboxNotifications[notification.id];
-    if (existingNotification) {
-      const result = compareInboxNotifications(
-        existingNotification,
-        notification
-      );
-      if (result === 1) return;
+function applyOptimisticUpdates_forSettings(settingsLUT, optimisticUpdates) {
+  const settingsByRoomId = Object.fromEntries(settingsLUT);
+  for (const optimisticUpdate of optimisticUpdates) {
+    switch (optimisticUpdate.type) {
+      case "update-notification-settings": {
+        const settings = settingsByRoomId[optimisticUpdate.roomId];
+        if (settings === void 0) {
+          break;
+        }
+        settingsByRoomId[optimisticUpdate.roomId] = {
+          ...settings,
+          ...optimisticUpdate.settings
+        };
+      }
     }
-    updatedInboxNotifications[notification.id] = notification;
-  });
-  updates.deletedNotifications.forEach(
-    ({ id }) => delete updatedInboxNotifications[id]
-  );
-  return updatedInboxNotifications;
+  }
+  return settingsByRoomId;
 }
 function compareInboxNotifications(inboxNotificationA, inboxNotificationB) {
   if (inboxNotificationA.notifiedAt > inboxNotificationB.notifiedAt) {
@@ -1542,6 +1741,7 @@ function upsertReaction(reactions, reaction) {
 }
 
 // src/liveblocks.tsx
+var _jsxruntime = require('react/jsx-runtime');
 var ClientContext = _react.createContext.call(void 0, null);
 function missingUserError(userId) {
   return new Error(`resolveUsers didn't return anything for user '${userId}'`);
@@ -1675,7 +1875,7 @@ function makeLiveblocksContextBundle(client) {
   const useDeleteAllInboxNotifications2 = () => useDeleteAllInboxNotifications_withClient(client);
   function LiveblocksProvider2(props) {
     useEnsureNoLiveblocksProvider();
-    return /* @__PURE__ */ React.default.createElement(ClientContext.Provider, { value: client }, props.children);
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ClientContext.Provider, { value: client, children: props.children });
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -1716,8 +1916,8 @@ function useInboxNotifications_withClient(client, selector, isEqual) {
       poller.dec();
     };
   }, [poller]);
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+  return useSyncExternalStoreWithSelector(
+    store.subscribe1_threads,
     store.getInboxNotificationsLoadingState,
     store.getInboxNotificationsLoadingState,
     selector,
@@ -1752,21 +1952,21 @@ function useMarkInboxNotificationAsRead_withClient(client) {
     (inboxNotificationId) => {
       const { store } = getLiveblocksExtrasForClient(client);
       const readAt = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-inbox-notification-as-read",
         inboxNotificationId,
         readAt
       });
       client.markInboxNotificationAsRead(inboxNotificationId).then(
         () => {
-          store.updateInboxNotification(
+          store.markInboxNotificationRead(
             inboxNotificationId,
-            optimisticUpdateId,
-            (inboxNotification) => ({ ...inboxNotification, readAt })
+            readAt,
+            optimisticId
           );
         },
         () => {
-          store.removeOptimisticUpdate(optimisticUpdateId);
+          store.optimisticUpdates.remove(optimisticId);
         }
       );
     },
@@ -1777,19 +1977,16 @@ function useMarkAllInboxNotificationsAsRead_withClient(client) {
   return _react.useCallback.call(void 0, () => {
     const { store } = getLiveblocksExtrasForClient(client);
     const readAt = /* @__PURE__ */ new Date();
-    const optimisticUpdateId = store.addOptimisticUpdate({
+    const optimisticId = store.optimisticUpdates.add({
       type: "mark-all-inbox-notifications-as-read",
       readAt
     });
     client.markAllInboxNotificationsAsRead().then(
       () => {
-        store.updateAllInboxNotifications(
-          optimisticUpdateId,
-          (inboxNotification) => ({ ...inboxNotification, readAt })
-        );
+        store.markAllInboxNotificationsRead(optimisticId, readAt);
       },
       () => {
-        store.removeOptimisticUpdate(optimisticUpdateId);
+        store.optimisticUpdates.remove(optimisticId);
       }
     );
   }, [client]);
@@ -1799,20 +1996,17 @@ function useDeleteInboxNotification_withClient(client) {
     (inboxNotificationId) => {
       const { store } = getLiveblocksExtrasForClient(client);
       const deletedAt = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-inbox-notification",
         inboxNotificationId,
         deletedAt
       });
       client.deleteInboxNotification(inboxNotificationId).then(
         () => {
-          store.deleteInboxNotification(
-            inboxNotificationId,
-            optimisticUpdateId
-          );
+          store.deleteInboxNotification(inboxNotificationId, optimisticId);
         },
         () => {
-          store.removeOptimisticUpdate(optimisticUpdateId);
+          store.optimisticUpdates.remove(optimisticId);
         }
       );
     },
@@ -1823,23 +2017,23 @@ function useDeleteAllInboxNotifications_withClient(client) {
   return _react.useCallback.call(void 0, () => {
     const { store } = getLiveblocksExtrasForClient(client);
     const deletedAt = /* @__PURE__ */ new Date();
-    const optimisticUpdateId = store.addOptimisticUpdate({
+    const optimisticId = store.optimisticUpdates.add({
       type: "delete-all-inbox-notifications",
       deletedAt
     });
     client.deleteAllInboxNotifications().then(
       () => {
-        store.deleteAllInboxNotifications(optimisticUpdateId);
+        store.deleteAllInboxNotifications(optimisticId);
       },
       () => {
-        store.removeOptimisticUpdate(optimisticUpdateId);
+        store.optimisticUpdates.remove(optimisticId);
       }
     );
   }, [client]);
 }
 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`)));
@@ -1855,8 +2049,8 @@ function useInboxNotificationThread_withClient(client, inboxNotificationId) {
     },
     [inboxNotificationId]
   );
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+  return useSyncExternalStoreWithSelector(
+    store.subscribe1_both,
     // Re-evaluate if we need to update any time the notification changes over time
     getter,
     getter,
@@ -1873,7 +2067,7 @@ function useUser_withClient(client, userId) {
     (state) => selectorFor_useUser(state, userId),
     [userId]
   );
-  const result = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  const result = useSyncExternalStoreWithSelector(
     usersStore.subscribe,
     getUserState,
     getUserState,
@@ -1901,7 +2095,7 @@ function useUserSuspense_withClient(client, userId) {
   if (!userState.data) {
     throw missingUserError(userId);
   }
-  const state = _indexjs.useSyncExternalStore.call(void 0, 
+  const state = _react.useSyncExternalStore.call(void 0, 
     usersStore.subscribe,
     getUserState,
     getUserState
@@ -1925,7 +2119,7 @@ function useRoomInfo_withClient(client, roomId) {
     (state) => selectorFor_useRoomInfo(state, roomId),
     [roomId]
   );
-  const result = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  const result = useSyncExternalStoreWithSelector(
     roomsInfoStore.subscribe,
     getRoomInfoState,
     getRoomInfoState,
@@ -1953,7 +2147,7 @@ function useRoomInfoSuspense_withClient(client, roomId) {
   if (!roomInfoState.data) {
     throw missingRoomInfoError(roomId);
   }
-  const state = _indexjs.useSyncExternalStore.call(void 0, 
+  const state = _react.useSyncExternalStore.call(void 0, 
     roomsInfoStore.subscribe,
     getRoomInfoState,
     getRoomInfoState
@@ -2006,7 +2200,7 @@ function useClient() {
 }
 function LiveblocksProviderWithClient(props) {
   useEnsureNoLiveblocksProvider(props);
-  return /* @__PURE__ */ React.default.createElement(ClientContext.Provider, { value: props.client }, props.children);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ClientContext.Provider, { value: props.client, children: props.children });
 }
 function LiveblocksProvider(props) {
   const { children, ...o } = props;
@@ -2035,7 +2229,7 @@ function LiveblocksProvider(props) {
     )
   };
   const client = _react.useMemo.call(void 0, () => _core.createClient.call(void 0, options), []);
-  return /* @__PURE__ */ React.default.createElement(LiveblocksProviderWithClient, { client }, children);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LiveblocksProviderWithClient, { client, children });
 }
 function createLiveblocksContext(client) {
   return getOrCreateContextBundle(client);
@@ -2071,8 +2265,8 @@ function useUserThreads_experimental(options = {
     () => store.getUserThreadsLoadingState(options.query),
     [store, options.query]
   );
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+  return useSyncExternalStoreWithSelector(
+    store.subscribe1_threads,
     getter,
     getter,
     identity,
@@ -2151,7 +2345,7 @@ function useSyncStatus_withClient(client, options) {
   }
 }
 function useSyncStatusImmediate_withClient(client) {
-  return _indexjs.useSyncExternalStore.call(void 0, 
+  return _react.useSyncExternalStore.call(void 0, 
     client.events.syncStatus.subscribe,
     client.getSyncStatus,
     client.getSyncStatus
@@ -2159,9 +2353,9 @@ function useSyncStatusImmediate_withClient(client) {
 }
 function useSyncStatusSmooth_withClient(client) {
   const getter = client.getSyncStatus;
-  const [status, setStatus] = React.default.useState(getter);
+  const [status, setStatus] = _react.useState.call(void 0, getter);
   const oldStatus = useLatest(getter());
-  React.default.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     let timeoutId;
     const unsub = client.events.syncStatus.subscribe(() => {
       const newStatus = getter();
@@ -2281,8 +2475,26 @@ 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,
+    _nullishCoalesce(selector, () => ( identity2)),
+    isEqual
+  );
+}
+
 // src/room.tsx
-var _client2 = require('@liveblocks/client');
+var _client = require('@liveblocks/client');
+
+
+
+
+
+
 
 
 
@@ -2319,7 +2531,7 @@ function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
   comment.scrollIntoView();
 }
 function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
-  React3.useEffect(
+  _react.useEffect.call(void 0, 
     () => {
       handleScrollToCommentOnLoad(shouldScrollOnLoad, state);
     },
@@ -2329,24 +2541,10 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 }
 
 // src/room.tsx
+
 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 _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, s, gs, gss, identity2);
-}
+var identity3 = (x) => x;
 var STABLE_EMPTY_LIST = Object.freeze([]);
 function alwaysEmptyList() {
   return STABLE_EMPTY_LIST;
@@ -2387,7 +2585,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";
   }
@@ -2422,8 +2620,8 @@ function getRoomExtrasForClient(client) {
 function makeRoomExtrasForClient(client) {
   const store = getUmbrellaStoreForClient(client);
   const commentsErrorEventSource = _core.makeEventSource.call(void 0, );
-  function onMutationFailure(innerError, optimisticUpdateId, createPublicError) {
-    store.removeOptimisticUpdate(optimisticUpdateId);
+  function onMutationFailure(innerError, optimisticId, createPublicError) {
+    store.optimisticUpdates.remove(optimisticId);
     if (innerError instanceof _core.HttpError) {
       const error = handleApiError(innerError);
       commentsErrorEventSource.notify(createPublicError(error));
@@ -2506,7 +2704,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__ */ _jsxruntime.jsx.call(void 0, LiveblocksProviderWithClient, { client, allowNesting: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, RoomProvider, { ...props }) });
   }
   const shared = createSharedContext(client);
   const bundle = {
@@ -2610,10 +2808,10 @@ function makeRoomContextBundle(client) {
 }
 function RoomProvider(props) {
   const client = useClient();
-  const [cache] = React4.useState(
+  const [cache] = _react.useState.call(void 0, 
     () => /* @__PURE__ */ new Map()
   );
-  const stableEnterRoom = React4.useCallback(
+  const stableEnterRoom = _react.useCallback.call(void 0, 
     (roomId, options) => {
       const cached = cache.get(roomId);
       if (cached) return cached;
@@ -2628,7 +2826,7 @@ function RoomProvider(props) {
     },
     [client, cache]
   );
-  return /* @__PURE__ */ React4.createElement(
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     RoomProviderInner,
     {
       ...props,
@@ -2648,31 +2846,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(_react.version) || 1;
+    const requiredVersion = 18;
     _core.errorIf.call(void 0, 
-      oldReactVersion && props.unstable_batchedUpdates === void 0,
-      missing_unstable_batchedUpdates(majorReactVersion, roomId)
-    );
-    _core.deprecateIf.call(void 0, 
-      !oldReactVersion && props.unstable_batchedUpdates !== void 0,
-      superfluous_unstable_batchedUpdates
+      majorReactVersion < requiredVersion,
+      `React ${requiredVersion} or higher is required (you\u2019re on ${_react.version})`
     );
   }
   const frozenProps = useInitial({
     initialPresence: props.initialPresence,
     initialStorage: props.initialStorage,
-    unstable_batchedUpdates: props.unstable_batchedUpdates,
     autoConnect: _nullishCoalesce(props.autoConnect, () => ( typeof window !== "undefined"))
   });
-  const [{ room }, setRoomLeavePair] = React4.useState(
+  const [{ room }, setRoomLeavePair] = _react.useState.call(void 0, 
     () => stableEnterRoom(roomId, {
       ...frozenProps,
       autoConnect: false
       // Deliberately using false here on the first render, see below
     })
   );
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     const { store } = getRoomExtrasForClient(client);
     async function handleCommentEvent(message) {
       if (message.type === _core.ServerMsgCode.THREAD_DELETED) {
@@ -2684,8 +2877,8 @@ function RoomProviderInner(props) {
         store.deleteThread(message.threadId, null);
         return;
       }
-      const { thread, inboxNotification } = info;
-      const existingThread = store.getFullState().threadsDB.getEvenIfDeleted(message.threadId);
+      const { thread, inboxNotification: maybeNotification } = info;
+      const existingThread = store.get1_threads().threadsDB.getEvenIfDeleted(message.threadId);
       switch (message.type) {
         case _core.ServerMsgCode.COMMENT_EDITED:
         case _core.ServerMsgCode.THREAD_METADATA_UPDATED:
@@ -2694,10 +2887,16 @@ function RoomProviderInner(props) {
         case _core.ServerMsgCode.COMMENT_REACTION_REMOVED:
         case _core.ServerMsgCode.COMMENT_DELETED:
           if (!existingThread) break;
-          store.updateThreadAndNotification(thread, inboxNotification);
+          store.updateThreadifications(
+            [thread],
+            maybeNotification ? [maybeNotification] : []
+          );
           break;
         case _core.ServerMsgCode.COMMENT_CREATED:
-          store.updateThreadAndNotification(thread, inboxNotification);
+          store.updateThreadifications(
+            [thread],
+            maybeNotification ? [maybeNotification] : []
+          );
           break;
         default:
           break;
@@ -2707,7 +2906,7 @@ function RoomProviderInner(props) {
       (message) => void handleCommentEvent(message)
     );
   }, [client, room]);
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     const pair = stableEnterRoom(roomId, frozenProps);
     setRoomLeavePair(pair);
     const { room: room2, leave } = pair;
@@ -2718,7 +2917,7 @@ function RoomProviderInner(props) {
       leave();
     };
   }, [roomId, frozenProps, stableEnterRoom]);
-  return /* @__PURE__ */ React4.createElement(RoomContext.Provider, { value: room }, props.children);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, RoomContext.Provider, { value: room, children: props.children });
 }
 function useRoom() {
   const room = useRoomOrNull();
@@ -2732,12 +2931,12 @@ function useStatus() {
   const subscribe = room.events.status.subscribe;
   const getSnapshot = room.getStatus;
   const getServerSnapshot = room.getStatus;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getServerSnapshot);
 }
 function useReportTextEditor(editor, rootKey) {
-  const isReported = React4.useRef(false);
+  const isReported = _react.useRef.call(void 0, false);
   const room = useRoom();
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     if (isReported.current) {
       return;
     }
@@ -2750,6 +2949,52 @@ function useReportTextEditor(editor, rootKey) {
     return unsubscribe;
   }, [room, editor, rootKey]);
 }
+function useYjsProvider() {
+  const room = useRoom();
+  const subscribe = _react.useCallback.call(void 0, 
+    (onStoreChange) => {
+      return room[_core.kInternal].yjsProviderDidChange.subscribe(onStoreChange);
+    },
+    [room]
+  );
+  const getSnapshot = _react.useCallback.call(void 0, () => {
+    return room[_core.kInternal].getYjsProvider();
+  }, [room]);
+  return _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getSnapshot);
+}
+function useCreateTextMention() {
+  const room = useRoom();
+  return _react.useCallback.call(void 0, 
+    (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 _react.useCallback.call(void 0, 
+    (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) {
@@ -2763,13 +3008,13 @@ function useStorageStatusImmediate() {
   const subscribe = room.events.storageStatus.subscribe;
   const getSnapshot = room.getStorageStatus;
   const getServerSnapshot = room.getStorageStatus;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getServerSnapshot);
 }
 function useStorageStatusSmooth() {
   const room = useRoom();
-  const [status, setStatus] = React4.useState(room.getStorageStatus);
+  const [status, setStatus] = _react.useState.call(void 0, room.getStorageStatus);
   const oldStatus = useLatest(room.getStorageStatus());
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     let timeoutId;
     const unsub = room.events.storageStatus.subscribe((newStatus) => {
       if (oldStatus.current === "synchronizing" && newStatus === "synchronized") {
@@ -2791,7 +3036,7 @@ function useBatch() {
 }
 function useBroadcastEvent() {
   const room = useRoom();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (event, options = { shouldQueueEventIfNotReady: false }) => {
       room.broadcastEvent(event, options);
     },
@@ -2801,7 +3046,7 @@ function useBroadcastEvent() {
 function useOthersListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => room.events.others.subscribe((event) => savedCallback.current(event)),
     [room, savedCallback]
   );
@@ -2809,7 +3054,7 @@ function useOthersListener(callback) {
 function useLostConnectionListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => room.events.lostConnection.subscribe(
       (event) => savedCallback.current(event)
     ),
@@ -2819,7 +3064,7 @@ function useLostConnectionListener(callback) {
 function useErrorListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => room.events.error.subscribe((e) => savedCallback.current(e)),
     [room, savedCallback]
   );
@@ -2827,7 +3072,7 @@ function useErrorListener(callback) {
 function useEventListener(callback) {
   const room = useRoom();
   const savedCallback = useLatest(callback);
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     const listener = (eventData) => {
       savedCallback.current(eventData);
     };
@@ -2847,25 +3092,25 @@ function useCanUndo() {
   const room = useRoom();
   const subscribe = room.events.history.subscribe;
   const canUndo = room.history.canUndo;
-  return useSyncExternalStore2(subscribe, canUndo, canUndo);
+  return _react.useSyncExternalStore.call(void 0, 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 _react.useSyncExternalStore.call(void 0, subscribe, canRedo, canRedo);
 }
 function useSelf(maybeSelector, isEqual) {
   const room = useRoom();
   const subscribe = room.events.self.subscribe;
   const getSnapshot = room.getSelf;
-  const selector = _nullishCoalesce(maybeSelector, () => ( identity2));
-  const wrappedSelector = React4.useCallback(
+  const selector = _nullishCoalesce(maybeSelector, () => ( identity3));
+  const wrappedSelector = _react.useCallback.call(void 0, 
     (me) => me !== null ? selector(me) : null,
     [selector]
   );
   const getServerSnapshot = alwaysNull;
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
@@ -2877,7 +3122,7 @@ function useMyPresence() {
   const room = useRoom();
   const subscribe = room.events.myPresence.subscribe;
   const getSnapshot = room.getPresence;
-  const presence = useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+  const presence = _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getSnapshot);
   const setPresence = room.updatePresence;
   return [presence, setPresence];
 }
@@ -2889,20 +3134,20 @@ function useOthers(selector, isEqual) {
   const subscribe = room.events.others.subscribe;
   const getSnapshot = room.getOthers;
   const getServerSnapshot = alwaysEmptyList;
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
-    _nullishCoalesce(selector, () => ( identity2)),
+    _nullishCoalesce(selector, () => ( identity3)),
     isEqual
   );
 }
 function useOthersMapped(itemSelector, itemIsEqual) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = _react.useCallback.call(void 0, 
     (others) => others.map((other) => [other.connectionId, itemSelector(other)]),
     [itemSelector]
   );
-  const wrappedIsEqual = React4.useCallback(
+  const wrappedIsEqual = _react.useCallback.call(void 0, 
     (a, b) => {
       const eq = _nullishCoalesce(itemIsEqual, () => ( Object.is));
       return a.length === b.length && a.every((atuple, index) => {
@@ -2915,18 +3160,18 @@ 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) {
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = _react.useCallback.call(void 0, 
     (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 = _react.useCallback.call(void 0, 
     (prev, curr) => {
       if (prev === NOT_FOUND || curr === NOT_FOUND) {
         return prev === curr;
@@ -2949,7 +3194,7 @@ function useMutableStorageRoot() {
   const subscribe = room.events.storageDidLoad.subscribeOnce;
   const getSnapshot = room.getStorageSnapshot;
   const getServerSnapshot = alwaysNull;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, getServerSnapshot);
 }
 function useStorageRoot() {
   return [useMutableStorageRoot()];
@@ -2957,15 +3202,15 @@ function useStorageRoot() {
 function useStorage(selector, isEqual) {
   const room = useRoom();
   const rootOrNull = useMutableStorageRoot();
-  const wrappedSelector = React4.useCallback(
+  const wrappedSelector = _react.useCallback.call(void 0, 
     (rootOrNull2) => rootOrNull2 !== null ? selector(rootOrNull2) : null,
     [selector]
   );
-  const subscribe = React4.useCallback(
+  const subscribe = _react.useCallback.call(void 0, 
     (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop3,
     [room, rootOrNull]
   );
-  const getSnapshot = React4.useCallback(() => {
+  const getSnapshot = _react.useCallback.call(void 0, () => {
     if (rootOrNull === null) {
       return null;
     } else {
@@ -2975,7 +3220,7 @@ function useStorage(selector, isEqual) {
     }
   }, [rootOrNull]);
   const getServerSnapshot = alwaysNull;
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  return useSyncExternalStoreWithSelector(
     subscribe,
     getSnapshot,
     getServerSnapshot,
@@ -2985,7 +3230,7 @@ function useStorage(selector, isEqual) {
 }
 function useMutation(callback, deps) {
   const room = useRoom();
-  return React4.useMemo(
+  return _react.useMemo.call(void 0, 
     () => {
       return (...args) => (
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -3012,7 +3257,7 @@ function useThreads(options = {
   const room = useRoom();
   const { store, getOrCreateThreadsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateThreadsPollerForRoomId(room.id);
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => {
       void store.waitUntilRoomThreadsLoaded(room.id, options.query);
     }
@@ -3025,20 +3270,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(() => {
+  _react.useEffect.call(void 0, () => {
     poller.inc();
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = _react.useCallback.call(void 0, 
     () => store.getRoomThreadsLoadingState(room.id, options.query),
     [store, room.id, options.query]
   );
-  const state = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    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 +3294,7 @@ function useCommentsErrorListener(callback) {
   const client = useClient();
   const savedCallback = useLatest(callback);
   const { commentsErrorEventSource } = getRoomExtrasForClient(client);
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     return commentsErrorEventSource.subscribe(savedCallback.current);
   }, [savedCallback, commentsErrorEventSource]);
 }
@@ -3058,7 +3303,7 @@ function useCreateThread() {
 }
 function useCreateRoomThread(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (options) => {
       const body = options.body;
       const metadata = _nullishCoalesce(options.metadata, () => ( {}));
@@ -3088,7 +3333,7 @@ function useCreateRoomThread(roomId) {
         resolved: false
       };
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "create-thread",
         thread: newThread,
         roomId
@@ -3103,11 +3348,11 @@ function useCreateRoomThread(roomId) {
         attachmentIds
       }).then(
         (thread) => {
-          store.createThread(optimisticUpdateId, thread);
+          store.createThread(optimisticId, thread);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new CreateThreadError(err2, {
             roomId,
             threadId,
@@ -3127,15 +3372,15 @@ function useDeleteThread() {
 }
 function useDeleteRoomThread(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (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");
       }
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-thread",
         roomId,
         threadId,
@@ -3143,11 +3388,11 @@ function useDeleteRoomThread(roomId) {
       });
       client[_core.kInternal].httpClient.deleteThread({ roomId, threadId }).then(
         () => {
-          store.deleteThread(threadId, optimisticUpdateId);
+          store.deleteThread(threadId, optimisticId);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new DeleteThreadError(err2, { roomId, threadId })
         )
       );
@@ -3160,7 +3405,7 @@ function useEditThreadMetadata() {
 }
 function useEditRoomThreadMetadata(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (options) => {
       if (!options.metadata) {
         return;
@@ -3169,7 +3414,7 @@ function useEditRoomThreadMetadata(roomId) {
       const metadata = options.metadata;
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "edit-thread-metadata",
         metadata,
         threadId,
@@ -3178,16 +3423,11 @@ function useEditRoomThreadMetadata(roomId) {
       client[_core.kInternal].httpClient.editThreadMetadata({ roomId, threadId, metadata }).then(
         (metadata2) => (
           // Replace the optimistic update by the real thing
-          store.patchThread(
-            threadId,
-            optimisticUpdateId,
-            { metadata: metadata2 },
-            updatedAt
-          )
+          store.patchThread(threadId, optimisticId, { metadata: metadata2 }, updatedAt)
         ),
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new EditThreadMetadataError(error, {
             roomId,
             threadId,
@@ -3204,7 +3444,7 @@ function useCreateComment() {
 }
 function useCreateRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     ({ threadId, body, attachments }) => {
       const commentId = _core.createCommentId.call(void 0, );
       const createdAt = /* @__PURE__ */ new Date();
@@ -3220,18 +3460,18 @@ function useCreateRoomComment(roomId) {
         attachments: _nullishCoalesce(attachments, () => ( []))
       };
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "create-comment",
         comment
       });
       const attachmentIds = _optionalChain([attachments, 'optionalAccess', _20 => _20.map, 'call', _21 => _21((attachment) => attachment.id)]);
       client[_core.kInternal].httpClient.createComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (newComment) => {
-          store.createComment(newComment, optimisticUpdateId);
+          store.createComment(newComment, optimisticId);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (err2) => new CreateCommentError(err2, {
             roomId,
             threadId,
@@ -3250,11 +3490,11 @@ function useEditComment() {
 }
 function useEditRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     ({ 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.`
@@ -3270,7 +3510,7 @@ function useEditRoomComment(roomId) {
         );
         return;
       }
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "edit-comment",
         comment: {
           ...comment,
@@ -3282,11 +3522,11 @@ function useEditRoomComment(roomId) {
       const attachmentIds = _optionalChain([attachments, 'optionalAccess', _22 => _22.map, 'call', _23 => _23((attachment) => attachment.id)]);
       client[_core.kInternal].httpClient.editComment({ roomId, threadId, commentId, body, attachmentIds }).then(
         (editedComment) => {
-          store.editComment(threadId, optimisticUpdateId, editedComment);
+          store.editComment(threadId, optimisticId, editedComment);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new EditCommentError(error, {
             roomId,
             threadId,
@@ -3304,11 +3544,11 @@ function useDeleteComment() {
 }
 function useDeleteRoomComment(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     ({ threadId, commentId }) => {
       const deletedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "delete-comment",
         threadId,
         commentId,
@@ -3317,16 +3557,11 @@ function useDeleteRoomComment(roomId) {
       });
       client[_core.kInternal].httpClient.deleteComment({ roomId, threadId, commentId }).then(
         () => {
-          store.deleteComment(
-            threadId,
-            optimisticUpdateId,
-            commentId,
-            deletedAt
-          );
+          store.deleteComment(threadId, optimisticId, commentId, deletedAt);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new DeleteCommentError(error, {
             roomId,
             threadId,
@@ -3343,12 +3578,12 @@ function useAddReaction() {
 }
 function useAddRoomCommentReaction(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     ({ threadId, commentId, emoji }) => {
       const createdAt = /* @__PURE__ */ new Date();
       const userId = getCurrentUserId(client);
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "add-reaction",
         threadId,
         commentId,
@@ -3362,7 +3597,7 @@ function useAddRoomCommentReaction(roomId) {
         (addedReaction) => {
           store.addReaction(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             commentId,
             addedReaction,
             createdAt
@@ -3370,7 +3605,7 @@ function useAddRoomCommentReaction(roomId) {
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new AddReactionError(error, {
             roomId,
             threadId,
@@ -3388,12 +3623,12 @@ function useRemoveReaction() {
 }
 function useRemoveRoomCommentReaction(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     ({ threadId, commentId, emoji }) => {
       const userId = getCurrentUserId(client);
       const removedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "remove-reaction",
         threadId,
         commentId,
@@ -3405,7 +3640,7 @@ function useRemoveRoomCommentReaction(roomId) {
         () => {
           store.removeReaction(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             commentId,
             emoji,
             userId,
@@ -3414,7 +3649,7 @@ function useRemoveRoomCommentReaction(roomId) {
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new RemoveReactionError(error, {
             roomId,
             threadId,
@@ -3432,17 +3667,17 @@ function useMarkThreadAsRead() {
 }
 function useMarkRoomThreadAsRead(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (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
       );
       if (!inboxNotification) return;
       const now = /* @__PURE__ */ new Date();
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-inbox-notification-as-read",
         inboxNotificationId: inboxNotification.id,
         readAt: now
@@ -3452,16 +3687,16 @@ function useMarkRoomThreadAsRead(roomId) {
         inboxNotificationId: inboxNotification.id
       }).then(
         () => {
-          store.updateInboxNotification(
+          store.markInboxNotificationRead(
             inboxNotification.id,
-            optimisticUpdateId,
-            (inboxNotification2) => ({ ...inboxNotification2, readAt: now })
+            now,
+            optimisticId
           );
         },
         (err) => {
           onMutationFailure(
             err,
-            optimisticUpdateId,
+            optimisticId,
             (error) => new MarkInboxNotificationAsReadError(error, {
               inboxNotificationId: inboxNotification.id
             })
@@ -3478,11 +3713,11 @@ function useMarkThreadAsResolved() {
 }
 function useMarkRoomThreadAsResolved(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-thread-as-resolved",
         threadId,
         updatedAt
@@ -3491,14 +3726,14 @@ function useMarkRoomThreadAsResolved(roomId) {
         () => {
           store.patchThread(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             { resolved: true },
             updatedAt
           );
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new MarkThreadAsResolvedError(error, {
             roomId,
             threadId
@@ -3514,11 +3749,11 @@ function useMarkThreadAsUnresolved() {
 }
 function useMarkRoomThreadAsUnresolved(roomId) {
   const client = useClient();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (threadId) => {
       const updatedAt = /* @__PURE__ */ new Date();
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "mark-thread-as-unresolved",
         threadId,
         updatedAt
@@ -3527,14 +3762,14 @@ function useMarkRoomThreadAsUnresolved(roomId) {
         () => {
           store.patchThread(
             threadId,
-            optimisticUpdateId,
+            optimisticId,
             { resolved: false },
             updatedAt
           );
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new MarkThreadAsUnresolvedError(error, {
             roomId,
             threadId
@@ -3548,9 +3783,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 = _react.useCallback.call(void 0, 
     (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 +3800,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();
@@ -3577,7 +3808,7 @@ function useRoomNotificationSettings() {
   const room = useRoom();
   const { store, getOrCreateNotificationsSettingsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateNotificationsSettingsPollerForRoomId(room.id);
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => {
       void store.waitUntilRoomNotificationSettingsLoaded(room.id);
     }
@@ -3590,25 +3821,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(() => {
+  _react.useEffect.call(void 0, () => {
     poller.inc();
     poller.pollNowIfStale();
     return () => {
       poller.dec();
     };
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = _react.useCallback.call(void 0, 
     () => store.getNotificationSettingsLoadingState(room.id),
     [store, room.id]
   );
-  const settings = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+  const settings = useSyncExternalStoreWithSelector(
+    store.subscribe2,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
-  return React4.useMemo(() => {
+  return _react.useMemo.call(void 0, () => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
@@ -3620,16 +3851,16 @@ function useRoomNotificationSettingsSuspense() {
   const [settings, updateRoomNotificationSettings] = useRoomNotificationSettings();
   _core.assert.call(void 0, !settings.error, "Did not expect error");
   _core.assert.call(void 0, !settings.isLoading, "Did not expect loading");
-  return React4.useMemo(() => {
+  return _react.useMemo.call(void 0, () => {
     return [settings, updateRoomNotificationSettings];
   }, [settings, updateRoomNotificationSettings]);
 }
 function useHistoryVersionData(versionId) {
-  const [state, setState] = React4.useState({
+  const [state, setState] = _react.useState.call(void 0, {
     isLoading: true
   });
   const room = useRoom();
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     setState({ isLoading: true });
     const load = async () => {
       try {
@@ -3658,16 +3889,16 @@ function useHistoryVersions() {
   const room = useRoom();
   const { store, getOrCreateVersionsPollerForRoomId } = getRoomExtrasForClient(client);
   const poller = getOrCreateVersionsPollerForRoomId(room.id);
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     poller.inc();
     poller.pollNowIfStale();
     return () => poller.dec();
   }, [poller]);
-  const getter = React4.useCallback(
+  const getter = _react.useCallback.call(void 0, 
     () => store.getRoomVersionsLoadingState(room.id),
     [store, room.id]
   );
-  React4.useEffect(
+  _react.useEffect.call(void 0, 
     () => {
       void store.waitUntilRoomVersionsLoaded(room.id);
     }
@@ -3680,11 +3911,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 = _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
-    store.subscribe,
+  const state = useSyncExternalStoreWithSelector(
+    store.subscribe3,
     getter,
     getter,
-    identity2,
+    identity3,
     shallow2
   );
   return state;
@@ -3702,25 +3933,21 @@ function useHistoryVersionsSuspense() {
 function useUpdateRoomNotificationSettings() {
   const client = useClient();
   const room = useRoom();
-  return React4.useCallback(
+  return _react.useCallback.call(void 0, 
     (settings) => {
       const { store, onMutationFailure } = getRoomExtrasForClient(client);
-      const optimisticUpdateId = store.addOptimisticUpdate({
+      const optimisticId = store.optimisticUpdates.add({
         type: "update-notification-settings",
         roomId: room.id,
         settings
       });
       room.updateNotificationSettings(settings).then(
         (settings2) => {
-          store.updateRoomNotificationSettings_confirmOptimisticUpdate(
-            room.id,
-            optimisticUpdateId,
-            settings2
-          );
+          store.updateRoomNotificationSettings(room.id, optimisticId, settings2);
         },
         (err) => onMutationFailure(
           err,
-          optimisticUpdateId,
+          optimisticId,
           (error) => new UpdateNotificationSettingsError(error, {
             roomId: room.id
           })
@@ -3816,25 +4043,25 @@ function useAttachmentUrl(attachmentId) {
 function useRoomAttachmentUrl(attachmentId, roomId) {
   const client = useClient();
   const store = client[_core.kInternal].httpClient.getOrCreateAttachmentUrlsStore(roomId);
-  const getAttachmentUrlState = React4.useCallback(
+  const getAttachmentUrlState = _react.useCallback.call(void 0, 
     () => store.getState(attachmentId),
     [store, attachmentId]
   );
-  React4.useEffect(() => {
+  _react.useEffect.call(void 0, () => {
     void store.get(attachmentId);
   }, [store, attachmentId]);
-  return _withselectorjs.useSyncExternalStoreWithSelector.call(void 0, 
+  return useSyncExternalStoreWithSelector(
     store.subscribe,
     getAttachmentUrlState,
     getAttachmentUrlState,
     selectorFor_useAttachmentUrl,
-    _client2.shallow
+    _client.shallow
   );
 }
 function useAttachmentUrlSuspense(attachmentId) {
   const room = useRoom();
   const { attachmentUrlsStore } = room[_core.kInternal];
-  const getAttachmentUrlState = React4.useCallback(
+  const getAttachmentUrlState = _react.useCallback.call(void 0, 
     () => attachmentUrlsStore.getState(attachmentId),
     [attachmentUrlsStore, attachmentId]
   );
@@ -3845,7 +4072,7 @@ function useAttachmentUrlSuspense(attachmentId) {
   if (attachmentUrlState.error) {
     throw attachmentUrlState.error;
   }
-  const state = useSyncExternalStore2(
+  const state = _react.useSyncExternalStore.call(void 0, 
     attachmentUrlsStore.subscribe,
     getAttachmentUrlState,
     getAttachmentUrlState
@@ -3862,11 +4089,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.permissionHints.signal,
+    (hints) => _nullishCoalesce(hints[roomId], () => ( /* @__PURE__ */ new Set()))
+  );
 }
 function createRoomContext(client) {
   return getOrCreateRoomContextBundle(client);
@@ -4007,5 +4233,12 @@ 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.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector; exports.ClientContext = ClientContext; exports.getUmbrellaStoreForClient = getUmbrellaStoreForClient; exports.useClientOrNull = useClientOrNull; exports.useClient = useClient; exports.LiveblocksProvider = LiveblocksProvider; exports.createLiveblocksContext = createLiveblocksContext; exports.useInboxNotifications = useInboxNotifications; exports.useInboxNotificationsSuspense = useInboxNotificationsSuspense; exports.useMarkAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead; exports.useMarkInboxNotificationAsRead = useMarkInboxNotificationAsRead; exports.useDeleteAllInboxNotifications = useDeleteAllInboxNotifications; exports.useDeleteInboxNotification = useDeleteInboxNotification; exports.useUnreadInboxNotificationsCount = useUnreadInboxNotificationsCount; exports.useUnreadInboxNotificationsCountSuspense = useUnreadInboxNotificationsCountSuspense; exports.useRoomInfo = useRoomInfo; exports.useRoomInfoSuspense = useRoomInfoSuspense; exports._useInboxNotificationThread = _useInboxNotificationThread; exports._useUser = _useUser; exports._useUserSuspense = _useUserSuspense; exports._useUserThreads_experimental = _useUserThreads_experimental; exports._useUserThreadsSuspense_experimental = _useUserThreadsSuspense_experimental; exports.useSyncStatus = useSyncStatus; exports.CreateThreadError = CreateThreadError; exports.useSignal = useSignal; exports.useStatus = useStatus; exports.useReportTextEditor = useReportTextEditor; exports.useYjsProvider = useYjsProvider; exports.useCreateTextMention = useCreateTextMention; exports.useDeleteTextMention = useDeleteTextMention; exports.useResolveMentionSuggestions = useResolveMentionSuggestions; exports.useMentionSuggestionsCache = useMentionSuggestionsCache; exports.useStorageStatus = useStorageStatus; exports.useBatch = useBatch; exports.useLostConnectionListener = useLostConnectionListener; exports.useErrorListener = useErrorListener; exports.useHistory = useHistory; exports.useUndo = useUndo; exports.useRedo = useRedo; exports.useCanUndo = useCanUndo; exports.useCanRedo = useCanRedo; exports.useOthersConnectionIds = useOthersConnectionIds; exports.useCommentsErrorListener = useCommentsErrorListener; exports.useCreateRoomThread = useCreateRoomThread; exports.useDeleteRoomThread = useDeleteRoomThread; exports.useEditRoomThreadMetadata = useEditRoomThreadMetadata; exports.useCreateComment = useCreateComment; exports.useCreateRoomComment = useCreateRoomComment; exports.useEditComment = useEditComment; exports.useEditRoomComment = useEditRoomComment; exports.useDeleteComment = useDeleteComment; exports.useDeleteRoomComment = useDeleteRoomComment; exports.useAddRoomCommentReaction = useAddRoomCommentReaction; exports.useRemoveReaction = useRemoveReaction; exports.useRemoveRoomCommentReaction = useRemoveRoomCommentReaction; exports.useMarkThreadAsRead = useMarkThreadAsRead; exports.useMarkRoomThreadAsRead = useMarkRoomThreadAsRead; exports.useMarkThreadAsResolved = useMarkThreadAsResolved; exports.useMarkRoomThreadAsResolved = useMarkRoomThreadAsResolved; exports.useMarkThreadAsUnresolved = useMarkThreadAsUnresolved; exports.useMarkRoomThreadAsUnresolved = useMarkRoomThreadAsUnresolved; exports.useThreadSubscription = useThreadSubscription; exports.useHistoryVersionData = useHistoryVersionData; exports.useUpdateRoomNotificationSettings = useUpdateRoomNotificationSettings; exports.useOthersConnectionIdsSuspense = useOthersConnectionIdsSuspense; exports.useStorageStatusSuspense = useStorageStatusSuspense; exports.useAttachmentUrl = useAttachmentUrl; exports.useRoomAttachmentUrl = useRoomAttachmentUrl; exports.useAttachmentUrlSuspense = useAttachmentUrlSuspense; exports.useRoomPermissions = useRoomPermissions; exports.createRoomContext = createRoomContext; exports._RoomProvider = _RoomProvider; exports._useBroadcastEvent = _useBroadcastEvent; exports._useOthersListener = _useOthersListener; exports._useRoom = _useRoom; exports._useIsInsideRoom = _useIsInsideRoom; exports._useAddReaction = _useAddReaction; exports._useMutation = _useMutation; exports._useCreateThread = _useCreateThread; exports._useDeleteThread = _useDeleteThread; exports._useEditThreadMetadata = _useEditThreadMetadata; exports._useEventListener = _useEventListener; exports._useMyPresence = _useMyPresence; exports._useOthersMapped = _useOthersMapped; exports._useOthersMappedSuspense = _useOthersMappedSuspense; exports._useThreads = _useThreads; exports._useThreadsSuspense = _useThreadsSuspense; exports._useRoomNotificationSettings = _useRoomNotificationSettings; exports._useRoomNotificationSettingsSuspense = _useRoomNotificationSettingsSuspense; exports._useHistoryVersions = _useHistoryVersions; exports._useHistoryVersionsSuspense = _useHistoryVersionsSuspense; exports._useOther = _useOther; exports._useOthers = _useOthers; exports._useOtherSuspense = _useOtherSuspense; exports._useOthersSuspense = _useOthersSuspense; exports._useStorage = _useStorage; exports._useStorageSuspense = _useStorageSuspense; exports._useSelf = _useSelf; exports._useSelfSuspense = _useSelfSuspense; exports._useStorageRoot = _useStorageRoot; exports._useUpdateMyPresence = _useUpdateMyPresence;
+//# sourceMappingURL=chunk-UKPVXB7D.js.map