@liveblocks/react 1.19.0-test1 → 2.0.0-alpha2

package/dist/chunk-HZXXTIZ4.mjs

@@ -0,0 +1,2432 @@
+// src/version.ts
+var PKG_NAME = "@liveblocks/react";
+var PKG_VERSION = "2.0.0-alpha2";
+var PKG_FORMAT = "esm";
+
+// src/ClientSideSuspense.tsx
+import * as React from "react";
+function ClientSideSuspense(props) {
+  const [mounted, setMounted] = React.useState(false);
+  React.useEffect(() => {
+    setMounted(true);
+  }, []);
+  return /* @__PURE__ */ React.createElement(React.Suspense, { fallback: props.fallback }, mounted ? props.children : props.fallback);
+}
+
+// src/liveblocks.tsx
+import { createClient, kInternal, makePoller, raise } from "@liveblocks/core";
+import { nanoid } from "nanoid";
+import React2, {
+  createContext,
+  useCallback as useCallback2,
+  useContext,
+  useEffect as useEffect3,
+  useMemo
+} from "react";
+import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
+
+// src/comments/lib/selected-inbox-notifications.ts
+import { applyOptimisticUpdates } from "@liveblocks/core";
+function selectedInboxNotifications(state) {
+  const result = applyOptimisticUpdates(state);
+  return Object.values(result.inboxNotifications).sort(
+    // Sort so that the most recent notifications are first
+    (a, b) => b.notifiedAt.getTime() - a.notifiedAt.getTime()
+  );
+}
+
+// src/lib/retry-error.ts
+var MAX_ERROR_RETRY_COUNT = 5;
+var ERROR_RETRY_INTERVAL = 5e3;
+function retryError(action, retryCount) {
+  if (retryCount >= MAX_ERROR_RETRY_COUNT) return;
+  const timeout = Math.pow(2, retryCount) * ERROR_RETRY_INTERVAL;
+  setTimeout(() => {
+    void action();
+  }, timeout);
+}
+
+// src/lib/use-initial.ts
+import { useCallback, useReducer } from "react";
+
+// src/lib/use-latest.ts
+import { useEffect as useEffect2, useRef } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  useEffect2(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// src/lib/use-initial.ts
+var noop = (state) => state;
+function useInitial(value) {
+  return useReducer(noop, value)[0];
+}
+function useInitialUnlessFunction(latestValue) {
+  const frozenValue = useInitial(latestValue);
+  if (typeof frozenValue === "function") {
+    const ref = useLatest(latestValue);
+    return useCallback((...args) => ref.current(...args), [
+      ref
+    ]);
+  } else {
+    return frozenValue;
+  }
+}
+
+// src/liveblocks.tsx
+var ClientContext = createContext(null);
+var missingUserError = new Error(
+  "resolveUsers didn't return anything for this user ID."
+);
+var missingRoomInfoError = new Error(
+  "resolveRoomsInfo didn't return anything for this room ID."
+);
+var _extras = /* @__PURE__ */ new WeakMap();
+var _bundles = /* @__PURE__ */ new WeakMap();
+var POLLING_INTERVAL = 60 * 1e3;
+var INBOX_NOTIFICATIONS_QUERY = "INBOX_NOTIFICATIONS";
+function selectorFor_useInboxNotifications(state) {
+  const query = state.queries[INBOX_NOTIFICATIONS_QUERY];
+  if (query === void 0 || query.isLoading) {
+    return {
+      isLoading: true
+    };
+  }
+  if (query.error !== void 0) {
+    return {
+      error: query.error,
+      isLoading: false
+    };
+  }
+  return {
+    inboxNotifications: selectedInboxNotifications(state),
+    isLoading: false
+  };
+}
+function selectorFor_useInboxNotificationsSuspense(state) {
+  return {
+    inboxNotifications: selectedInboxNotifications(state),
+    isLoading: false
+  };
+}
+function selectUnreadInboxNotificationsCount(state) {
+  let count = 0;
+  for (const notification of selectedInboxNotifications(state)) {
+    if (notification.readAt === null || notification.readAt < notification.notifiedAt) {
+      count++;
+    }
+  }
+  return count;
+}
+function selectorFor_useUnreadInboxNotificationsCount(state) {
+  const query = state.queries[INBOX_NOTIFICATIONS_QUERY];
+  if (query === void 0 || query.isLoading) {
+    return {
+      isLoading: true
+    };
+  }
+  if (query.error !== void 0) {
+    return {
+      error: query.error,
+      isLoading: false
+    };
+  }
+  return {
+    isLoading: false,
+    count: selectUnreadInboxNotificationsCount(state)
+  };
+}
+function selectorFor_useUnreadInboxNotificationsCountSuspense(state) {
+  return {
+    isLoading: false,
+    count: selectUnreadInboxNotificationsCount(state)
+  };
+}
+function getOrCreateContextBundle(client) {
+  let bundle = _bundles.get(client);
+  if (!bundle) {
+    bundle = makeLiveblocksContextBundle(client);
+    _bundles.set(client, bundle);
+  }
+  return bundle;
+}
+function getExtrasForClient(client) {
+  let extras = _extras.get(client);
+  if (!extras) {
+    extras = makeExtrasForClient(client);
+    _extras.set(client, extras);
+  }
+  return extras;
+}
+function makeExtrasForClient(client) {
+  const internals = client[kInternal];
+  const store = internals.cacheStore;
+  const notifications = internals.notifications;
+  let fetchInboxNotificationsRequest = null;
+  let lastRequestedAt;
+  const poller = makePoller(
+    () => notifications.getInboxNotifications({ since: lastRequestedAt }).then(
+      (result) => {
+        lastRequestedAt = result.meta.requestedAt;
+        store.updateThreadsAndNotifications(
+          result.threads,
+          result.inboxNotifications,
+          result.deletedThreads,
+          result.deletedInboxNotifications,
+          INBOX_NOTIFICATIONS_QUERY
+        );
+      },
+      () => {
+      }
+    )
+  );
+  async function fetchInboxNotifications({ retryCount } = { retryCount: 0 }) {
+    if (fetchInboxNotificationsRequest !== null) {
+      return fetchInboxNotificationsRequest;
+    }
+    store.setQueryState(INBOX_NOTIFICATIONS_QUERY, {
+      isLoading: true
+    });
+    try {
+      fetchInboxNotificationsRequest = notifications.getInboxNotifications();
+      const result = await fetchInboxNotificationsRequest;
+      store.updateThreadsAndNotifications(
+        result.threads,
+        result.inboxNotifications,
+        result.deletedThreads,
+        result.deletedInboxNotifications,
+        INBOX_NOTIFICATIONS_QUERY
+      );
+      if (lastRequestedAt === void 0 || lastRequestedAt > result.meta.requestedAt) {
+        lastRequestedAt = result.meta.requestedAt;
+      }
+      poller.start(POLLING_INTERVAL);
+    } catch (er) {
+      fetchInboxNotificationsRequest = null;
+      retryError(() => {
+        void fetchInboxNotifications({
+          retryCount: retryCount + 1
+        });
+      }, retryCount);
+      store.setQueryState(INBOX_NOTIFICATIONS_QUERY, {
+        isLoading: false,
+        error: er
+      });
+    }
+    return;
+  }
+  let inboxNotificationsSubscribers = 0;
+  function useSubscribeToInboxNotificationsEffect(options) {
+    const autoFetch = useInitial(options?.autoFetch ?? true);
+    useEffect3(() => {
+      if (autoFetch) {
+        void fetchInboxNotifications();
+      }
+      inboxNotificationsSubscribers++;
+      poller.start(POLLING_INTERVAL);
+      return () => {
+        if (inboxNotificationsSubscribers <= 0) {
+          console.warn(
+            `Internal unexpected behavior. Cannot decrease subscriber count for query "${INBOX_NOTIFICATIONS_QUERY}"`
+          );
+          return;
+        }
+        inboxNotificationsSubscribers--;
+        if (inboxNotificationsSubscribers <= 0) {
+          poller.stop();
+        }
+      };
+    }, [autoFetch]);
+  }
+  return {
+    store,
+    notifications,
+    fetchInboxNotifications,
+    useSubscribeToInboxNotificationsEffect
+  };
+}
+function makeLiveblocksContextBundle(client) {
+  const useInboxNotificationThread2 = (inboxNotificationId) => useInboxNotificationThread_withClient(client, inboxNotificationId);
+  const useMarkInboxNotificationAsRead2 = () => useMarkInboxNotificationAsRead_withClient(client);
+  const useMarkAllInboxNotificationsAsRead2 = () => useMarkAllInboxNotificationsAsRead_withClient(client);
+  function LiveblocksProvider2(props) {
+    return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: client }, props.children);
+  }
+  const shared = createSharedContext(client);
+  const bundle = {
+    LiveblocksProvider: LiveblocksProvider2,
+    useInboxNotifications: () => useInboxNotifications_withClient(client),
+    useUnreadInboxNotificationsCount: () => useUnreadInboxNotificationsCount_withClient(client),
+    useMarkInboxNotificationAsRead: useMarkInboxNotificationAsRead2,
+    useMarkAllInboxNotificationsAsRead: useMarkAllInboxNotificationsAsRead2,
+    useInboxNotificationThread: useInboxNotificationThread2,
+    ...shared.classic,
+    suspense: {
+      LiveblocksProvider: LiveblocksProvider2,
+      useInboxNotifications: () => useInboxNotificationsSuspense_withClient(client),
+      useUnreadInboxNotificationsCount: () => useUnreadInboxNotificationsCountSuspense_withClient(client),
+      useMarkInboxNotificationAsRead: useMarkInboxNotificationAsRead2,
+      useMarkAllInboxNotificationsAsRead: useMarkAllInboxNotificationsAsRead2,
+      useInboxNotificationThread: useInboxNotificationThread2,
+      ...shared.suspense
+    }
+  };
+  return bundle;
+}
+function useInboxNotifications_withClient(client) {
+  const { store, useSubscribeToInboxNotificationsEffect } = getExtrasForClient(client);
+  useSubscribeToInboxNotificationsEffect();
+  return useSyncExternalStoreWithSelector(
+    store.subscribe,
+    store.get,
+    store.get,
+    selectorFor_useInboxNotifications
+  );
+}
+function useInboxNotificationsSuspense_withClient(client) {
+  const {
+    store,
+    fetchInboxNotifications,
+    useSubscribeToInboxNotificationsEffect
+  } = getExtrasForClient(client);
+  const query = store.get().queries[INBOX_NOTIFICATIONS_QUERY];
+  if (query === void 0 || query.isLoading) {
+    throw fetchInboxNotifications();
+  }
+  if (query.error !== void 0) {
+    throw query.error;
+  }
+  useSubscribeToInboxNotificationsEffect({ autoFetch: false });
+  return useSyncExternalStoreWithSelector(
+    store.subscribe,
+    store.get,
+    store.get,
+    selectorFor_useInboxNotificationsSuspense
+  );
+}
+function useUnreadInboxNotificationsCount_withClient(client) {
+  const { store, useSubscribeToInboxNotificationsEffect } = getExtrasForClient(client);
+  useSubscribeToInboxNotificationsEffect();
+  return useSyncExternalStoreWithSelector(
+    store.subscribe,
+    store.get,
+    store.get,
+    selectorFor_useUnreadInboxNotificationsCount
+  );
+}
+function useUnreadInboxNotificationsCountSuspense_withClient(client) {
+  const {
+    store,
+    fetchInboxNotifications,
+    useSubscribeToInboxNotificationsEffect
+  } = getExtrasForClient(client);
+  const query = store.get().queries[INBOX_NOTIFICATIONS_QUERY];
+  if (query === void 0 || query.isLoading) {
+    throw fetchInboxNotifications();
+  }
+  useSubscribeToInboxNotificationsEffect({ autoFetch: false });
+  return useSyncExternalStoreWithSelector(
+    store.subscribe,
+    store.get,
+    store.get,
+    selectorFor_useUnreadInboxNotificationsCountSuspense
+  );
+}
+function useMarkInboxNotificationAsRead_withClient(client) {
+  return useCallback2(
+    (inboxNotificationId) => {
+      const { store, notifications } = getExtrasForClient(client);
+      const optimisticUpdateId = nanoid();
+      const readAt = /* @__PURE__ */ new Date();
+      store.pushOptimisticUpdate({
+        type: "mark-inbox-notification-as-read",
+        id: optimisticUpdateId,
+        inboxNotificationId,
+        readAt
+      });
+      notifications.markInboxNotificationAsRead(inboxNotificationId).then(
+        () => {
+          store.set((state) => {
+            const existingNotification = state.inboxNotifications[inboxNotificationId];
+            if (existingNotification === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: state.optimisticUpdates.filter(
+                  (update) => update.id !== optimisticUpdateId
+                )
+              };
+            }
+            return {
+              ...state,
+              inboxNotifications: {
+                ...state.inboxNotifications,
+                [inboxNotificationId]: {
+                  ...existingNotification,
+                  readAt
+                }
+              },
+              optimisticUpdates: state.optimisticUpdates.filter(
+                (update) => update.id !== optimisticUpdateId
+              )
+            };
+          });
+        },
+        () => {
+          store.set((state) => ({
+            ...state,
+            optimisticUpdates: state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            )
+          }));
+        }
+      );
+    },
+    [client]
+  );
+}
+function useMarkAllInboxNotificationsAsRead_withClient(client) {
+  return useCallback2(() => {
+    const { store, notifications } = getExtrasForClient(client);
+    const optimisticUpdateId = nanoid();
+    const readAt = /* @__PURE__ */ new Date();
+    store.pushOptimisticUpdate({
+      type: "mark-inbox-notifications-as-read",
+      id: optimisticUpdateId,
+      readAt
+    });
+    notifications.markAllInboxNotificationsAsRead().then(
+      () => {
+        store.set((state) => ({
+          ...state,
+          inboxNotifications: Object.fromEntries(
+            Array.from(Object.entries(state.inboxNotifications)).map(
+              ([id, inboxNotification]) => [
+                id,
+                { ...inboxNotification, readAt }
+              ]
+            )
+          ),
+          optimisticUpdates: state.optimisticUpdates.filter(
+            (update) => update.id !== optimisticUpdateId
+          )
+        }));
+      },
+      () => {
+        store.set((state) => ({
+          ...state,
+          optimisticUpdates: state.optimisticUpdates.filter(
+            (update) => update.id !== optimisticUpdateId
+          )
+        }));
+      }
+    );
+  }, [client]);
+}
+function useInboxNotificationThread_withClient(client, inboxNotificationId) {
+  const { store } = getExtrasForClient(client);
+  const selector = useCallback2(
+    (state) => {
+      const inboxNotification = state.inboxNotifications[inboxNotificationId] ?? raise(`Inbox notification with ID "${inboxNotificationId}" not found`);
+      if (inboxNotification.kind !== "thread") {
+        raise(
+          `Inbox notification with ID "${inboxNotificationId}" is not of kind "thread"`
+        );
+      }
+      const thread = state.threads[inboxNotification.threadId] ?? raise(
+        `Thread with ID "${inboxNotification.threadId}" not found, this inbox notification might not be of kind "thread"`
+      );
+      return thread;
+    },
+    [inboxNotificationId]
+  );
+  return useSyncExternalStoreWithSelector(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+}
+function useUser_withClient(client, userId) {
+  const usersStore = client[kInternal].usersStore;
+  const getUserState = useCallback2(
+    () => usersStore.getState(userId),
+    [usersStore, userId]
+  );
+  useEffect3(() => {
+    void usersStore.get(userId);
+  }, [usersStore, userId]);
+  const state = useSyncExternalStore(
+    usersStore.subscribe,
+    getUserState,
+    getUserState
+  );
+  return state ? {
+    isLoading: state.isLoading,
+    user: state.data,
+    // Return an error if `undefined` was returned by `resolveUsers` for this user ID
+    error: !state.isLoading && !state.data && !state.error ? missingUserError : state.error
+  } : { isLoading: true };
+}
+function useUserSuspense_withClient(client, userId) {
+  const usersStore = client[kInternal].usersStore;
+  const getUserState = useCallback2(
+    () => usersStore.getState(userId),
+    [usersStore, userId]
+  );
+  const userState = getUserState();
+  if (!userState || userState.isLoading) {
+    throw usersStore.get(userId);
+  }
+  if (userState.error) {
+    throw userState.error;
+  }
+  if (!userState.data) {
+    throw missingUserError;
+  }
+  const state = useSyncExternalStore(
+    usersStore.subscribe,
+    getUserState,
+    getUserState
+  );
+  return {
+    isLoading: false,
+    user: state?.data,
+    error: state?.error
+  };
+}
+function useRoomInfo_withClient(client, roomId) {
+  const roomsInfoStore = client[kInternal].roomsInfoStore;
+  const getRoomInfoState = useCallback2(
+    () => roomsInfoStore.getState(roomId),
+    [roomsInfoStore, roomId]
+  );
+  useEffect3(() => {
+    void roomsInfoStore.get(roomId);
+  }, [roomsInfoStore, roomId]);
+  const state = useSyncExternalStore(
+    roomsInfoStore.subscribe,
+    getRoomInfoState,
+    getRoomInfoState
+  );
+  return state ? {
+    isLoading: state.isLoading,
+    info: state.data,
+    // Return an error if `undefined` was returned by `resolveRoomsInfo` for this room ID
+    error: !state.isLoading && !state.data && !state.error ? missingRoomInfoError : state.error
+  } : { isLoading: true };
+}
+function useRoomInfoSuspense_withClient(client, roomId) {
+  const roomsInfoStore = client[kInternal].roomsInfoStore;
+  const getRoomInfoState = useCallback2(
+    () => roomsInfoStore.getState(roomId),
+    [roomsInfoStore, roomId]
+  );
+  const roomInfoState = getRoomInfoState();
+  if (!roomInfoState || roomInfoState.isLoading) {
+    throw roomsInfoStore.get(roomId);
+  }
+  if (roomInfoState.error) {
+    throw roomInfoState.error;
+  }
+  if (!roomInfoState.data) {
+    throw missingRoomInfoError;
+  }
+  const state = useSyncExternalStore(
+    roomsInfoStore.subscribe,
+    getRoomInfoState,
+    getRoomInfoState
+  );
+  return {
+    isLoading: false,
+    info: state?.data,
+    error: state?.error
+  };
+}
+function createSharedContext(client) {
+  return {
+    classic: {
+      useUser: (userId) => useUser_withClient(client, userId),
+      useRoomInfo: (roomId) => useRoomInfo_withClient(client, roomId)
+    },
+    suspense: {
+      useUser: (userId) => useUserSuspense_withClient(client, userId),
+      useRoomInfo: (roomId) => useRoomInfoSuspense_withClient(client, roomId)
+    }
+  };
+}
+function useClientOrNull() {
+  return useContext(ClientContext);
+}
+function useClient() {
+  return useClientOrNull() ?? raise("LiveblocksProvider is missing from the React tree.");
+}
+function LiveblocksProviderWithClient(props) {
+  return /* @__PURE__ */ React2.createElement(ClientContext.Provider, { value: props.client }, props.children);
+}
+function LiveblocksProvider(props) {
+  const { children, ...o } = props;
+  const options = {
+    publicApiKey: useInitial(o.publicApiKey),
+    throttle: useInitial(o.throttle),
+    lostConnectionTimeout: useInitial(o.lostConnectionTimeout),
+    backgroundKeepAliveTimeout: useInitial(o.backgroundKeepAliveTimeout),
+    polyfills: useInitial(o.polyfills),
+    unstable_fallbackToHTTP: useInitial(o.unstable_fallbackToHTTP),
+    unstable_streamData: useInitial(o.unstable_streamData),
+    authEndpoint: useInitialUnlessFunction(o.authEndpoint),
+    resolveMentionSuggestions: useInitialUnlessFunction(
+      o.resolveMentionSuggestions
+    ),
+    resolveUsers: useInitialUnlessFunction(o.resolveUsers),
+    resolveRoomsInfo: useInitialUnlessFunction(o.resolveRoomsInfo),
+    baseUrl: useInitial(
+      // @ts-expect-error - Hidden config options
+      o.baseUrl
+    ),
+    enableDebugLogging: useInitial(
+      // @ts-expect-error - Hidden config options
+      o.enableDebugLogging
+    )
+  };
+  const client = useMemo(() => createClient(options), []);
+  return /* @__PURE__ */ React2.createElement(LiveblocksProviderWithClient, { client }, children);
+}
+function createLiveblocksContext(client) {
+  return getOrCreateContextBundle(client);
+}
+function useInboxNotifications() {
+  return useInboxNotifications_withClient(useClient());
+}
+function useInboxNotificationsSuspense() {
+  return useInboxNotificationsSuspense_withClient(useClient());
+}
+function useInboxNotificationThread(inboxNotificationId) {
+  return useInboxNotificationThread_withClient(
+    useClient(),
+    inboxNotificationId
+  );
+}
+function useMarkAllInboxNotificationsAsRead() {
+  return useMarkAllInboxNotificationsAsRead_withClient(useClient());
+}
+function useMarkInboxNotificationAsRead() {
+  return useMarkInboxNotificationAsRead_withClient(useClient());
+}
+function useUnreadInboxNotificationsCount() {
+  return useUnreadInboxNotificationsCount_withClient(useClient());
+}
+function useUnreadInboxNotificationsCountSuspense() {
+  return useUnreadInboxNotificationsCountSuspense_withClient(useClient());
+}
+function useUser(userId) {
+  const client = useClient();
+  return useUser_withClient(client, userId);
+}
+function useUserSuspense(userId) {
+  const client = useClient();
+  return useUserSuspense_withClient(client, userId);
+}
+function useRoomInfo(roomId) {
+  return useRoomInfo_withClient(useClient(), roomId);
+}
+function useRoomInfoSuspense(roomId) {
+  return useRoomInfoSuspense_withClient(useClient(), roomId);
+}
+var __1 = useInboxNotificationThread;
+var __2 = useUser;
+var __3 = useUserSuspense;
+
+// src/comments/errors.ts
+var CreateThreadError = class extends Error {
+  constructor(cause, context) {
+    super("Create thread failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "CreateThreadError";
+  }
+};
+var EditThreadMetadataError = class extends Error {
+  constructor(cause, context) {
+    super("Edit thread metadata failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "EditThreadMetadataError";
+  }
+};
+var CreateCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Create comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "CreateCommentError";
+  }
+};
+var EditCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Edit comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "EditCommentError";
+  }
+};
+var DeleteCommentError = class extends Error {
+  constructor(cause, context) {
+    super("Delete comment failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "DeleteCommentError";
+  }
+};
+var AddReactionError = class extends Error {
+  constructor(cause, context) {
+    super("Add reaction failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "AddReactionError";
+  }
+};
+var RemoveReactionError = class extends Error {
+  constructor(cause, context) {
+    super("Remove reaction failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "RemoveReactionError";
+  }
+};
+var MarkInboxNotificationAsReadError = class extends Error {
+  constructor(cause, context) {
+    super("Mark inbox notification as read failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkInboxNotificationAsReadError";
+  }
+};
+var UpdateNotificationSettingsError = class extends Error {
+  constructor(cause, context) {
+    super("Update notification settings failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "UpdateNotificationSettingsError";
+  }
+};
+
+// src/comments/lib/selected-threads.ts
+import {
+  applyOptimisticUpdates as applyOptimisticUpdates2
+} from "@liveblocks/core";
+function selectedThreads(roomId, state, options) {
+  const result = applyOptimisticUpdates2(state);
+  const threads = Object.values(result.threads).filter(
+    (thread) => {
+      if (thread.roomId !== roomId) return false;
+      if (thread.deletedAt !== void 0) {
+        return false;
+      }
+      const query = options.query;
+      if (!query) return true;
+      for (const key in query.metadata) {
+        const metadataValue = thread.metadata[key];
+        const filterValue = query.metadata[key];
+        if (assertFilterIsStartsWithOperator(filterValue) && assertMetadataValueIsString(metadataValue)) {
+          if (metadataValue.startsWith(filterValue.startsWith)) {
+            return true;
+          }
+        }
+        if (metadataValue !== filterValue) {
+          return false;
+        }
+      }
+      return true;
+    }
+  );
+  return threads.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+}
+var assertFilterIsStartsWithOperator = (filter) => {
+  if (typeof filter === "object" && typeof filter.startsWith === "string") {
+    return true;
+  } else {
+    return false;
+  }
+};
+var assertMetadataValueIsString = (value) => {
+  return typeof value === "string";
+};
+
+// src/room.tsx
+import { shallow } from "@liveblocks/client";
+import {
+  addReaction,
+  CommentsApiError,
+  console as console2,
+  deleteComment,
+  deprecateIf,
+  errorIf,
+  kInternal as kInternal2,
+  makeEventSource,
+  makePoller as makePoller2,
+  NotificationsApiError,
+  removeReaction,
+  ServerMsgCode,
+  stringify,
+  upsertComment
+} from "@liveblocks/core";
+import { nanoid as nanoid3 } from "nanoid";
+import * as React4 from "react";
+import { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from "use-sync-external-store/shim/with-selector.js";
+
+// src/comments/lib/createIds.ts
+import { nanoid as nanoid2 } from "nanoid";
+var THREAD_ID_PREFIX = "th";
+var COMMENT_ID_PREFIX = "cm";
+function createOptimisticId(prefix) {
+  return `${prefix}_${nanoid2()}`;
+}
+function createThreadId() {
+  return createOptimisticId(THREAD_ID_PREFIX);
+}
+function createCommentId() {
+  return createOptimisticId(COMMENT_ID_PREFIX);
+}
+
+// src/comments/lib/select-notification-settings.ts
+import {
+  applyOptimisticUpdates as applyOptimisticUpdates3,
+  nn
+} from "@liveblocks/core";
+function selectNotificationSettings(roomId, state) {
+  const { notificationSettings } = applyOptimisticUpdates3(state);
+  return nn(notificationSettings[roomId]);
+}
+
+// src/use-scroll-to-comment-on-load-effect.ts
+import * as React3 from "react";
+function handleScrollToCommentOnLoad(shouldScrollOnLoad, state) {
+  if (shouldScrollOnLoad === false) return;
+  if (state.isLoading) return;
+  const isWindowDefined = typeof window !== "undefined";
+  if (!isWindowDefined) return;
+  const hash = window.location.hash;
+  const commentId = hash.slice(1);
+  if (!commentId.startsWith("cm_")) return;
+  const comment = document.getElementById(commentId);
+  if (comment === null) return;
+  const comments = state.threads.flatMap((thread) => thread.comments);
+  const isCommentInThreads = comments.some(
+    (comment2) => comment2.id === commentId
+  );
+  if (!isCommentInThreads) return;
+  comment.scrollIntoView();
+}
+function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
+  React3.useEffect(
+    () => {
+      handleScrollToCommentOnLoad(shouldScrollOnLoad, state);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- We only want to run this effect once
+    [state.isLoading]
+  );
+}
+
+// src/room.tsx
+var noop2 = () => {
+};
+var identity = (x) => x;
+var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\u2019re using React ${reactVersion}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
+
+    import { unstable_batchedUpdates } from "react-dom";  // or "react-native"
+
+    <RoomProvider id=${JSON.stringify(
+  roomId
+)} ... unstable_batchedUpdates={unstable_batchedUpdates}>
+      ...
+    </RoomProvider>
+
+Why? Please see https://liveblocks.io/docs/platform/troubleshooting#stale-props-zombie-child for more information`;
+var superfluous_unstable_batchedUpdates = "You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";
+function useSyncExternalStore2(s, gs, gss) {
+  return useSyncExternalStoreWithSelector2(s, gs, gss, identity);
+}
+var STABLE_EMPTY_LIST = Object.freeze([]);
+var POLLING_INTERVAL2 = 5 * 60 * 1e3;
+function makeNotificationSettingsQueryKey(roomId) {
+  return `${roomId}:NOTIFICATION_SETTINGS`;
+}
+function alwaysEmptyList() {
+  return STABLE_EMPTY_LIST;
+}
+function alwaysNull() {
+  return null;
+}
+function selectorFor_useOthersConnectionIds(others) {
+  return others.map((user) => user.connectionId);
+}
+function makeMutationContext(room) {
+  const cannotUseUntil = "This mutation cannot be used until";
+  const needsPresence = `${cannotUseUntil} connected to the Liveblocks room`;
+  const needsStorage = `${cannotUseUntil} storage has been loaded`;
+  return {
+    get storage() {
+      const mutableRoot = room.getStorageSnapshot();
+      if (mutableRoot === null) {
+        throw new Error(needsStorage);
+      }
+      return mutableRoot;
+    },
+    get self() {
+      const self = room.getSelf();
+      if (self === null) {
+        throw new Error(needsPresence);
+      }
+      return self;
+    },
+    get others() {
+      const others = room.getOthers();
+      if (room.getSelf() === null) {
+        throw new Error(needsPresence);
+      }
+      return others;
+    },
+    setMyPresence: room.updatePresence
+  };
+}
+function getCurrentUserId(room) {
+  const self = room.getSelf();
+  if (self === null || self.id === void 0) {
+    return "anonymous";
+  } else {
+    return self.id;
+  }
+}
+function handleApiError(err) {
+  const message = `Request failed with status ${err.status}: ${err.message}`;
+  if (err.details?.error === "FORBIDDEN") {
+    const detailedMessage = [message, err.details.suggestion, err.details.docs].filter(Boolean).join("\n");
+    console2.error(detailedMessage);
+  }
+  return new Error(message);
+}
+var _extras2 = /* @__PURE__ */ new WeakMap();
+var _bundles2 = /* @__PURE__ */ new WeakMap();
+function getOrCreateRoomContextBundle(client) {
+  let bundle = _bundles2.get(client);
+  if (!bundle) {
+    bundle = makeRoomContextBundle(client);
+    _bundles2.set(client, bundle);
+  }
+  return bundle;
+}
+function getExtrasForClient2(client) {
+  let extras = _extras2.get(client);
+  if (!extras) {
+    extras = makeExtrasForClient2(client);
+    _extras2.set(client, extras);
+  }
+  return extras;
+}
+function makeExtrasForClient2(client) {
+  const store = client[kInternal2].cacheStore;
+  const DEFAULT_DEDUPING_INTERVAL = 2e3;
+  const lastRequestedAtByRoom = /* @__PURE__ */ new Map();
+  const requestsByQuery = /* @__PURE__ */ new Map();
+  const requestStatusByRoom = /* @__PURE__ */ new Map();
+  const subscribersByQuery = /* @__PURE__ */ new Map();
+  const poller = makePoller2(refreshThreadsAndNotifications);
+  async function refreshThreadsAndNotifications() {
+    const requests = [];
+    client[kInternal2].getRoomIds().map((roomId) => {
+      const room = client.getRoom(roomId);
+      if (room === null) return;
+      requests.push(getThreadsUpdates(room.id));
+    });
+    await Promise.allSettled(requests);
+  }
+  function incrementQuerySubscribers(queryKey) {
+    const subscribers = subscribersByQuery.get(queryKey) ?? 0;
+    subscribersByQuery.set(queryKey, subscribers + 1);
+    poller.start(POLLING_INTERVAL2);
+    return () => {
+      const subscribers2 = subscribersByQuery.get(queryKey);
+      if (subscribers2 === void 0 || subscribers2 <= 0) {
+        console2.warn(
+          `Internal unexpected behavior. Cannot decrease subscriber count for query "${queryKey}"`
+        );
+        return;
+      }
+      subscribersByQuery.set(queryKey, subscribers2 - 1);
+      let totalSubscribers = 0;
+      for (const subscribers3 of subscribersByQuery.values()) {
+        totalSubscribers += subscribers3;
+      }
+      if (totalSubscribers <= 0) {
+        poller.stop();
+      }
+    };
+  }
+  async function getThreadsUpdates(roomId) {
+    const room = client.getRoom(roomId);
+    if (room === null) return;
+    const since = lastRequestedAtByRoom.get(room.id);
+    if (since === void 0) return;
+    const isFetchingThreadsUpdates = requestStatusByRoom.get(room.id) ?? false;
+    if (isFetchingThreadsUpdates === true) return;
+    try {
+      requestStatusByRoom.set(room.id, true);
+      const commentsAPI = room[kInternal2].comments;
+      const updates = await commentsAPI.getThreads({ since });
+      setTimeout(() => {
+        requestStatusByRoom.set(room.id, false);
+      }, DEFAULT_DEDUPING_INTERVAL);
+      store.updateThreadsAndNotifications(
+        updates.threads,
+        updates.inboxNotifications,
+        updates.deletedThreads,
+        updates.deletedInboxNotifications
+      );
+      lastRequestedAtByRoom.set(room.id, updates.meta.requestedAt);
+    } catch (err) {
+      requestStatusByRoom.set(room.id, false);
+      return;
+    }
+  }
+  async function getThreadsAndInboxNotifications(room, queryKey, options, { retryCount } = { retryCount: 0 }) {
+    const existingRequest = requestsByQuery.get(queryKey);
+    if (existingRequest !== void 0) return existingRequest;
+    const commentsAPI = room[kInternal2].comments;
+    const request = commentsAPI.getThreads(options);
+    requestsByQuery.set(queryKey, request);
+    store.setQueryState(queryKey, {
+      isLoading: true
+    });
+    try {
+      const result = await request;
+      store.updateThreadsAndNotifications(
+        result.threads,
+        result.inboxNotifications,
+        result.deletedThreads,
+        result.deletedInboxNotifications,
+        queryKey
+      );
+      const lastRequestedAt = lastRequestedAtByRoom.get(room.id);
+      if (lastRequestedAt === void 0 || lastRequestedAt > result.meta.requestedAt) {
+        lastRequestedAtByRoom.set(room.id, result.meta.requestedAt);
+      }
+      poller.start(POLLING_INTERVAL2);
+    } catch (err) {
+      requestsByQuery.delete(queryKey);
+      retryError(() => {
+        void getThreadsAndInboxNotifications(room, queryKey, options, {
+          retryCount: retryCount + 1
+        });
+      }, retryCount);
+      store.setQueryState(queryKey, {
+        isLoading: false,
+        error: err
+      });
+    }
+    return;
+  }
+  async function getInboxNotificationSettings(room, queryKey, { retryCount } = { retryCount: 0 }) {
+    const existingRequest = requestsByQuery.get(queryKey);
+    if (existingRequest !== void 0) return existingRequest;
+    try {
+      const request = room[kInternal2].notifications.getRoomNotificationSettings();
+      requestsByQuery.set(queryKey, request);
+      store.setQueryState(queryKey, {
+        isLoading: true
+      });
+      const settings = await request;
+      store.updateRoomInboxNotificationSettings(room.id, settings, queryKey);
+    } catch (err) {
+      requestsByQuery.delete(queryKey);
+      retryError(() => {
+        void getInboxNotificationSettings(room, queryKey, {
+          retryCount: retryCount + 1
+        });
+      }, retryCount);
+      store.setQueryState(queryKey, {
+        isLoading: false,
+        error: err
+      });
+    }
+    return;
+  }
+  const commentsErrorEventSource = makeEventSource();
+  function onMutationFailure(innerError, optimisticUpdateId, createPublicError) {
+    store.set((state) => ({
+      ...state,
+      optimisticUpdates: state.optimisticUpdates.filter(
+        (update) => update.id !== optimisticUpdateId
+      )
+    }));
+    if (innerError instanceof CommentsApiError) {
+      const error = handleApiError(innerError);
+      commentsErrorEventSource.notify(createPublicError(error));
+      return;
+    }
+    if (innerError instanceof NotificationsApiError) {
+      handleApiError(innerError);
+      return;
+    }
+    throw innerError;
+  }
+  return {
+    store,
+    incrementQuerySubscribers,
+    commentsErrorEventSource,
+    getThreadsUpdates,
+    getThreadsAndInboxNotifications,
+    getInboxNotificationSettings,
+    onMutationFailure
+  };
+}
+var RoomContext = React4.createContext(null);
+function makeRoomContextBundle(client) {
+  function RoomProvider_withImplicitLiveblocksProvider(props) {
+    return /* @__PURE__ */ React4.createElement(LiveblocksProviderWithClient, { client }, /* @__PURE__ */ React4.createElement(RoomProvider, { ...props }));
+  }
+  const shared = createSharedContext(client);
+  const bundle = {
+    RoomContext,
+    RoomProvider: RoomProvider_withImplicitLiveblocksProvider,
+    useRoom,
+    useStatus,
+    useBatch,
+    useBroadcastEvent,
+    useOthersListener,
+    useLostConnectionListener,
+    useErrorListener,
+    useEventListener,
+    useHistory,
+    useUndo,
+    useRedo,
+    useCanRedo,
+    useCanUndo,
+    useStorageRoot,
+    useStorage,
+    useSelf,
+    useMyPresence,
+    useUpdateMyPresence,
+    useOthers,
+    useOthersMapped,
+    useOthersConnectionIds,
+    useOther,
+    useMutation,
+    useThreads,
+    useCreateThread,
+    useEditThreadMetadata,
+    useCreateComment,
+    useEditComment,
+    useDeleteComment,
+    useAddReaction,
+    useRemoveReaction,
+    useMarkThreadAsRead,
+    useThreadSubscription,
+    useRoomNotificationSettings,
+    useUpdateRoomNotificationSettings,
+    ...shared.classic,
+    suspense: {
+      RoomContext,
+      RoomProvider: RoomProvider_withImplicitLiveblocksProvider,
+      useRoom,
+      useStatus,
+      useBatch,
+      useBroadcastEvent,
+      useOthersListener,
+      useLostConnectionListener,
+      useErrorListener,
+      useEventListener,
+      useHistory,
+      useUndo,
+      useRedo,
+      useCanRedo,
+      useCanUndo,
+      useStorageRoot,
+      useStorage: useStorageSuspense,
+      useSelf: useSelfSuspense,
+      useMyPresence,
+      useUpdateMyPresence,
+      useOthers: useOthersSuspense,
+      useOthersMapped: useOthersMappedSuspense,
+      useOthersConnectionIds: useOthersConnectionIdsSuspense,
+      useOther: useOtherSuspense,
+      useMutation,
+      useThreads: useThreadsSuspense,
+      useCreateThread,
+      useEditThreadMetadata,
+      useCreateComment,
+      useEditComment,
+      useDeleteComment,
+      useAddReaction,
+      useRemoveReaction,
+      useMarkThreadAsRead,
+      useThreadSubscription,
+      useRoomNotificationSettings: useRoomNotificationSettingsSuspense,
+      useUpdateRoomNotificationSettings,
+      ...shared.suspense
+    },
+    useCommentsErrorListener
+  };
+  return Object.defineProperty(bundle, kInternal2, {
+    enumerable: false
+  });
+}
+function RoomProvider(props) {
+  const client = useClient();
+  const [cache] = React4.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const stableEnterRoom = React4.useCallback(
+    (roomId, options) => {
+      const cached = cache.get(roomId);
+      if (cached) return cached;
+      const rv = client.enterRoom(roomId, options);
+      const origLeave = rv.leave;
+      rv.leave = () => {
+        origLeave();
+        cache.delete(roomId);
+      };
+      cache.set(roomId, rv);
+      return rv;
+    },
+    [client, cache]
+  );
+  return /* @__PURE__ */ React4.createElement(RoomProviderInner, { ...props, stableEnterRoom });
+}
+function RoomProviderInner(props) {
+  const client = useClient();
+  const { id: roomId, stableEnterRoom } = props;
+  if (process.env.NODE_ENV !== "production") {
+    if (!roomId) {
+      throw new Error(
+        "RoomProvider id property is required. For more information: https://liveblocks.io/docs/errors/liveblocks-react/RoomProvider-id-property-is-required"
+      );
+    }
+    if (typeof roomId !== "string") {
+      throw new Error("RoomProvider id property should be a string.");
+    }
+    const majorReactVersion = parseInt(React4.version) || 1;
+    const oldReactVersion = majorReactVersion < 18;
+    errorIf(
+      oldReactVersion && props.unstable_batchedUpdates === void 0,
+      missing_unstable_batchedUpdates(majorReactVersion, roomId)
+    );
+    deprecateIf(
+      !oldReactVersion && props.unstable_batchedUpdates !== void 0,
+      superfluous_unstable_batchedUpdates
+    );
+  }
+  const frozenProps = useInitial({
+    initialPresence: props.initialPresence,
+    initialStorage: props.initialStorage,
+    unstable_batchedUpdates: props.unstable_batchedUpdates,
+    autoConnect: props.autoConnect ?? typeof window !== "undefined"
+  });
+  const [{ room }, setRoomLeavePair] = React4.useState(
+    () => stableEnterRoom(roomId, {
+      ...frozenProps,
+      autoConnect: false
+      // Deliberately using false here on the first render, see below
+    })
+  );
+  React4.useEffect(() => {
+    const { store } = getExtrasForClient2(client);
+    async function handleCommentEvent(message) {
+      const info = await room[kInternal2].comments.getThread({
+        threadId: message.threadId
+      });
+      if (!info) {
+        store.deleteThread(message.threadId);
+        return;
+      }
+      const { thread, inboxNotification } = info;
+      const existingThread = store.get().threads[message.threadId];
+      switch (message.type) {
+        case ServerMsgCode.COMMENT_EDITED:
+        case ServerMsgCode.THREAD_METADATA_UPDATED:
+        case ServerMsgCode.COMMENT_REACTION_ADDED:
+        case ServerMsgCode.COMMENT_REACTION_REMOVED:
+        case ServerMsgCode.COMMENT_DELETED:
+          if (!existingThread) break;
+          store.updateThreadAndNotification(thread, inboxNotification);
+          break;
+        case ServerMsgCode.COMMENT_CREATED:
+          store.updateThreadAndNotification(thread, inboxNotification);
+          break;
+        default:
+          break;
+      }
+    }
+    return room.events.comments.subscribe(
+      (message) => void handleCommentEvent(message)
+    );
+  }, [client, room]);
+  React4.useEffect(() => {
+    const { getThreadsUpdates } = getExtrasForClient2(client);
+    void getThreadsUpdates(room.id);
+  }, [client, room.id]);
+  React4.useEffect(() => {
+    function handleIsOnline() {
+      const { getThreadsUpdates } = getExtrasForClient2(client);
+      void getThreadsUpdates(room.id);
+    }
+    window.addEventListener("online", handleIsOnline);
+    return () => {
+      window.removeEventListener("online", handleIsOnline);
+    };
+  }, [client, room.id]);
+  React4.useEffect(() => {
+    const pair = stableEnterRoom(roomId, frozenProps);
+    setRoomLeavePair(pair);
+    const { room: room2, leave } = pair;
+    if (frozenProps.autoConnect) {
+      room2.connect();
+    }
+    return () => {
+      leave();
+    };
+  }, [roomId, frozenProps, stableEnterRoom]);
+  return /* @__PURE__ */ React4.createElement(RoomContext.Provider, { value: room }, props.children);
+}
+function useRoom() {
+  const room = useRoomOrNull();
+  if (room === null) {
+    throw new Error("RoomProvider is missing from the React tree.");
+  }
+  return room;
+}
+function useStatus() {
+  const room = useRoom();
+  const subscribe = room.events.status.subscribe;
+  const getSnapshot = room.getStatus;
+  const getServerSnapshot = room.getStatus;
+  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+}
+function useBatch() {
+  return useRoom().batch;
+}
+function useBroadcastEvent() {
+  const room = useRoom();
+  return React4.useCallback(
+    (event, options = { shouldQueueEventIfNotReady: false }) => {
+      room.broadcastEvent(event, options);
+    },
+    [room]
+  );
+}
+function useOthersListener(callback) {
+  const room = useRoom();
+  const savedCallback = useLatest(callback);
+  React4.useEffect(
+    () => room.events.others.subscribe((event) => savedCallback.current(event)),
+    [room, savedCallback]
+  );
+}
+function useLostConnectionListener(callback) {
+  const room = useRoom();
+  const savedCallback = useLatest(callback);
+  React4.useEffect(
+    () => room.events.lostConnection.subscribe(
+      (event) => savedCallback.current(event)
+    ),
+    [room, savedCallback]
+  );
+}
+function useErrorListener(callback) {
+  const room = useRoom();
+  const savedCallback = useLatest(callback);
+  React4.useEffect(
+    () => room.events.error.subscribe((e) => savedCallback.current(e)),
+    [room, savedCallback]
+  );
+}
+function useEventListener(callback) {
+  const room = useRoom();
+  const savedCallback = useLatest(callback);
+  React4.useEffect(() => {
+    const listener = (eventData) => {
+      savedCallback.current(eventData);
+    };
+    return room.events.customEvent.subscribe(listener);
+  }, [room, savedCallback]);
+}
+function useHistory() {
+  return useRoom().history;
+}
+function useUndo() {
+  return useHistory().undo;
+}
+function useRedo() {
+  return useHistory().redo;
+}
+function useCanUndo() {
+  const room = useRoom();
+  const subscribe = room.events.history.subscribe;
+  const canUndo = room.history.canUndo;
+  return useSyncExternalStore2(subscribe, canUndo, canUndo);
+}
+function useCanRedo() {
+  const room = useRoom();
+  const subscribe = room.events.history.subscribe;
+  const canRedo = room.history.canRedo;
+  return useSyncExternalStore2(subscribe, canRedo, canRedo);
+}
+function useSelf(maybeSelector, isEqual) {
+  const room = useRoom();
+  const subscribe = room.events.self.subscribe;
+  const getSnapshot = room.getSelf;
+  const selector = maybeSelector ?? identity;
+  const wrappedSelector = React4.useCallback(
+    (me) => me !== null ? selector(me) : null,
+    [selector]
+  );
+  const getServerSnapshot = alwaysNull;
+  return useSyncExternalStoreWithSelector2(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    wrappedSelector,
+    isEqual
+  );
+}
+function useMyPresence() {
+  const room = useRoom();
+  const subscribe = room.events.myPresence.subscribe;
+  const getSnapshot = room.getPresence;
+  const presence = useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+  const setPresence = room.updatePresence;
+  return [presence, setPresence];
+}
+function useUpdateMyPresence() {
+  return useRoom().updatePresence;
+}
+function useOthers(selector, isEqual) {
+  const room = useRoom();
+  const subscribe = room.events.others.subscribe;
+  const getSnapshot = room.getOthers;
+  const getServerSnapshot = alwaysEmptyList;
+  return useSyncExternalStoreWithSelector2(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    selector ?? identity,
+    isEqual
+  );
+}
+function useOthersMapped(itemSelector, itemIsEqual) {
+  const wrappedSelector = React4.useCallback(
+    (others) => others.map((other) => [other.connectionId, itemSelector(other)]),
+    [itemSelector]
+  );
+  const wrappedIsEqual = React4.useCallback(
+    (a, b) => {
+      const eq = itemIsEqual ?? Object.is;
+      return a.length === b.length && a.every((atuple, index) => {
+        const btuple = b[index];
+        return atuple[0] === btuple[0] && eq(atuple[1], btuple[1]);
+      });
+    },
+    [itemIsEqual]
+  );
+  return useOthers(wrappedSelector, wrappedIsEqual);
+}
+function useOthersConnectionIds() {
+  return useOthers(selectorFor_useOthersConnectionIds, shallow);
+}
+var NOT_FOUND = Symbol();
+function useOther(connectionId, selector, isEqual) {
+  const wrappedSelector = React4.useCallback(
+    (others) => {
+      const other2 = others.find((other3) => other3.connectionId === connectionId);
+      return other2 !== void 0 ? selector(other2) : NOT_FOUND;
+    },
+    [connectionId, selector]
+  );
+  const wrappedIsEqual = React4.useCallback(
+    (prev, curr) => {
+      if (prev === NOT_FOUND || curr === NOT_FOUND) {
+        return prev === curr;
+      }
+      const eq = isEqual ?? Object.is;
+      return eq(prev, curr);
+    },
+    [isEqual]
+  );
+  const other = useOthers(wrappedSelector, wrappedIsEqual);
+  if (other === NOT_FOUND) {
+    throw new Error(
+      `No such other user with connection id ${connectionId} exists`
+    );
+  }
+  return other;
+}
+function useMutableStorageRoot() {
+  const room = useRoom();
+  const subscribe = room.events.storageDidLoad.subscribeOnce;
+  const getSnapshot = room.getStorageSnapshot;
+  const getServerSnapshot = alwaysNull;
+  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+}
+function useStorageRoot() {
+  return [useMutableStorageRoot()];
+}
+function useStorage(selector, isEqual) {
+  const room = useRoom();
+  const rootOrNull = useMutableStorageRoot();
+  const wrappedSelector = React4.useCallback(
+    (rootOrNull2) => rootOrNull2 !== null ? selector(rootOrNull2) : null,
+    [selector]
+  );
+  const subscribe = React4.useCallback(
+    (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop2,
+    [room, rootOrNull]
+  );
+  const getSnapshot = React4.useCallback(() => {
+    if (rootOrNull === null) {
+      return null;
+    } else {
+      const root = rootOrNull;
+      const imm = root.toImmutable();
+      return imm;
+    }
+  }, [rootOrNull]);
+  const getServerSnapshot = alwaysNull;
+  return useSyncExternalStoreWithSelector2(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    wrappedSelector,
+    isEqual
+  );
+}
+function useMutation(callback, deps) {
+  const room = useRoom();
+  return React4.useMemo(
+    () => {
+      return (...args) => (
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        room.batch(
+          () => (
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            callback(
+              makeMutationContext(room),
+              ...args
+            )
+          )
+        )
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [room, ...deps]
+  );
+}
+function useThreads(options = {
+  query: { metadata: {} }
+}) {
+  const { scrollOnLoad = true } = options;
+  const client = useClient();
+  const room = useRoom();
+  const queryKey = React4.useMemo(
+    () => generateQueryKey(room.id, options.query),
+    [room, options]
+  );
+  const { store, getThreadsAndInboxNotifications, incrementQuerySubscribers } = getExtrasForClient2(client);
+  React4.useEffect(() => {
+    void getThreadsAndInboxNotifications(room, queryKey, options);
+    return incrementQuerySubscribers(queryKey);
+  }, [room, queryKey]);
+  const selector = React4.useCallback(
+    (state2) => {
+      const query = state2.queries[queryKey];
+      if (query === void 0 || query.isLoading) {
+        return {
+          isLoading: true
+        };
+      }
+      return {
+        threads: selectedThreads(room.id, state2, options),
+        isLoading: false,
+        error: query.error
+      };
+    },
+    [room, queryKey]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  const state = useSyncExternalStoreWithSelector2(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+  useScrollToCommentOnLoadEffect(scrollOnLoad, state);
+  return state;
+}
+function useCommentsErrorListener(callback) {
+  const client = useClient();
+  const savedCallback = useLatest(callback);
+  const { commentsErrorEventSource } = getExtrasForClient2(client);
+  React4.useEffect(() => {
+    return commentsErrorEventSource.subscribe(savedCallback.current);
+  }, [savedCallback, commentsErrorEventSource]);
+}
+function useCreateThread() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (options) => {
+      const body = options.body;
+      const metadata = options.metadata ?? {};
+      const threadId = createThreadId();
+      const commentId = createCommentId();
+      const createdAt = /* @__PURE__ */ new Date();
+      const newComment = {
+        id: commentId,
+        threadId,
+        roomId: room.id,
+        createdAt,
+        type: "comment",
+        userId: getCurrentUserId(room),
+        body,
+        reactions: []
+      };
+      const newThread = {
+        id: threadId,
+        type: "thread",
+        createdAt,
+        updatedAt: createdAt,
+        roomId: room.id,
+        metadata,
+        comments: [newComment]
+      };
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "create-thread",
+        thread: newThread,
+        id: optimisticUpdateId,
+        roomId: room.id
+      });
+      const commentsAPI = room[kInternal2].comments;
+      commentsAPI.createThread({ threadId, commentId, body, metadata }).then(
+        (thread) => {
+          store.set((state) => ({
+            ...state,
+            threads: {
+              ...state.threads,
+              [threadId]: thread
+            },
+            optimisticUpdates: state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            )
+          }));
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (err2) => new CreateThreadError(err2, {
+            roomId: room.id,
+            threadId,
+            commentId,
+            body,
+            metadata
+          })
+        )
+      );
+      return newThread;
+    },
+    [client, room]
+  );
+}
+function useEditThreadMetadata() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (options) => {
+      if (!options.metadata) {
+        return;
+      }
+      const threadId = options.threadId;
+      const metadata = options.metadata;
+      const updatedAt = /* @__PURE__ */ new Date();
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "edit-thread-metadata",
+        metadata,
+        id: optimisticUpdateId,
+        threadId,
+        updatedAt
+      });
+      const commentsAPI = room[kInternal2].comments;
+      commentsAPI.editThreadMetadata({ metadata, threadId }).then(
+        (metadata2) => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.deletedAt !== void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.updatedAt && existingThread.updatedAt > updatedAt) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: {
+                  ...existingThread,
+                  metadata: metadata2
+                }
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new EditThreadMetadataError(error, {
+            roomId: room.id,
+            threadId,
+            metadata
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useCreateComment() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    ({ threadId, body }) => {
+      const commentId = createCommentId();
+      const createdAt = /* @__PURE__ */ new Date();
+      const comment = {
+        id: commentId,
+        threadId,
+        roomId: room.id,
+        type: "comment",
+        createdAt,
+        userId: getCurrentUserId(room),
+        body,
+        reactions: []
+      };
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "create-comment",
+        comment,
+        id: optimisticUpdateId
+      });
+      room[kInternal2].comments.createComment({ threadId, commentId, body }).then(
+        (newComment) => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            const inboxNotification = Object.values(
+              state.inboxNotifications
+            ).find(
+              (notification) => notification.kind === "thread" && notification.threadId === threadId
+            );
+            const updatedInboxNotifications = inboxNotification !== void 0 ? {
+              ...state.inboxNotifications,
+              [inboxNotification.id]: {
+                ...inboxNotification,
+                notifiedAt: newComment.createdAt,
+                readAt: newComment.createdAt
+              }
+            } : state.inboxNotifications;
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: upsertComment(existingThread, newComment)
+                // Upsert the new comment into the thread comments list (if applicable)
+              },
+              inboxNotifications: updatedInboxNotifications,
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (err2) => new CreateCommentError(err2, {
+            roomId: room.id,
+            threadId,
+            commentId,
+            body
+          })
+        )
+      );
+      return comment;
+    },
+    [client, room]
+  );
+}
+function useEditComment() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    ({ threadId, commentId, body }) => {
+      const editedAt = /* @__PURE__ */ new Date();
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const thread = store.get().threads[threadId];
+      if (thread === void 0) {
+        console2.warn(
+          `Internal unexpected behavior. Cannot edit comment in thread "${threadId}" because the thread does not exist in the cache.`
+        );
+        return;
+      }
+      const comment = thread.comments.find(
+        (comment2) => comment2.id === commentId
+      );
+      if (comment === void 0 || comment.deletedAt !== void 0) {
+        console2.warn(
+          `Internal unexpected behavior. Cannot edit comment "${commentId}" in thread "${threadId}" because the comment does not exist in the cache.`
+        );
+        return;
+      }
+      store.pushOptimisticUpdate({
+        type: "edit-comment",
+        comment: {
+          ...comment,
+          editedAt,
+          body
+        },
+        id: optimisticUpdateId
+      });
+      room[kInternal2].comments.editComment({ threadId, commentId, body }).then(
+        (editedComment) => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: upsertComment(existingThread, editedComment)
+                // Upsert the edited comment into the thread comments list (if applicable)
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new EditCommentError(error, {
+            roomId: room.id,
+            threadId,
+            commentId,
+            body
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useDeleteComment() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    ({ threadId, commentId }) => {
+      const deletedAt = /* @__PURE__ */ new Date();
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "delete-comment",
+        threadId,
+        commentId,
+        deletedAt,
+        id: optimisticUpdateId,
+        roomId: room.id
+      });
+      room[kInternal2].comments.deleteComment({ threadId, commentId }).then(
+        () => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: deleteComment(existingThread, commentId, deletedAt)
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new DeleteCommentError(error, {
+            roomId: room.id,
+            threadId,
+            commentId
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useAddReaction() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    ({ threadId, commentId, emoji }) => {
+      const createdAt = /* @__PURE__ */ new Date();
+      const userId = getCurrentUserId(room);
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "add-reaction",
+        threadId,
+        commentId,
+        reaction: {
+          emoji,
+          userId,
+          createdAt
+        },
+        id: optimisticUpdateId
+      });
+      room[kInternal2].comments.addReaction({ threadId, commentId, emoji }).then(
+        (addedReaction) => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: addReaction(
+                  existingThread,
+                  commentId,
+                  addedReaction
+                )
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new AddReactionError(error, {
+            roomId: room.id,
+            threadId,
+            commentId,
+            emoji
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useRemoveReaction() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    ({ threadId, commentId, emoji }) => {
+      const userId = getCurrentUserId(room);
+      const removedAt = /* @__PURE__ */ new Date();
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "remove-reaction",
+        threadId,
+        commentId,
+        emoji,
+        userId,
+        removedAt,
+        id: optimisticUpdateId
+      });
+      room[kInternal2].comments.removeReaction({ threadId, commentId, emoji }).then(
+        () => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: removeReaction(
+                  existingThread,
+                  commentId,
+                  emoji,
+                  userId,
+                  removedAt
+                )
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new RemoveReactionError(error, {
+            roomId: room.id,
+            threadId,
+            commentId,
+            emoji
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useMarkThreadAsRead() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (threadId) => {
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      const inboxNotification = Object.values(
+        store.get().inboxNotifications
+      ).find(
+        (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
+      );
+      if (!inboxNotification) return;
+      const optimisticUpdateId = nanoid3();
+      const now = /* @__PURE__ */ new Date();
+      store.pushOptimisticUpdate({
+        type: "mark-inbox-notification-as-read",
+        id: optimisticUpdateId,
+        inboxNotificationId: inboxNotification.id,
+        readAt: now
+      });
+      room[kInternal2].notifications.markInboxNotificationAsRead(inboxNotification.id).then(
+        () => {
+          store.set((state) => ({
+            ...state,
+            inboxNotifications: {
+              ...state.inboxNotifications,
+              [inboxNotification.id]: {
+                ...inboxNotification,
+                readAt: now
+              }
+            },
+            optimisticUpdates: state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            )
+          }));
+        },
+        (err) => {
+          onMutationFailure(
+            err,
+            optimisticUpdateId,
+            (error) => new MarkInboxNotificationAsReadError(error, {
+              inboxNotificationId: inboxNotification.id
+            })
+          );
+          return;
+        }
+      );
+    },
+    [client, room]
+  );
+}
+function useThreadSubscription(threadId) {
+  const client = useClient();
+  const { store } = getExtrasForClient2(client);
+  const selector = React4.useCallback(
+    (state) => {
+      const inboxNotification = selectedInboxNotifications(state).find(
+        (inboxNotification2) => inboxNotification2.kind === "thread" && inboxNotification2.threadId === threadId
+      );
+      const thread = state.threads[threadId];
+      if (inboxNotification === void 0 || thread === void 0) {
+        return {
+          status: "not-subscribed"
+        };
+      }
+      return {
+        status: "subscribed",
+        unreadSince: inboxNotification.readAt
+      };
+    },
+    [threadId]
+  );
+  return useSyncExternalStoreWithSelector2(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+}
+function useRoomNotificationSettings() {
+  const client = useClient();
+  const room = useRoom();
+  const { store } = getExtrasForClient2(client);
+  React4.useEffect(() => {
+    const { getInboxNotificationSettings } = getExtrasForClient2(client);
+    const queryKey = makeNotificationSettingsQueryKey(room.id);
+    void getInboxNotificationSettings(room, queryKey);
+  }, [client, room]);
+  const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
+  const selector = React4.useCallback(
+    (state) => {
+      const query = state.queries[makeNotificationSettingsQueryKey(room.id)];
+      if (query === void 0 || query.isLoading) {
+        return { isLoading: true };
+      }
+      if (query.error !== void 0) {
+        return { isLoading: false, error: query.error };
+      }
+      return {
+        isLoading: false,
+        settings: selectNotificationSettings(room.id, state)
+      };
+    },
+    [room]
+  );
+  const settings = useSyncExternalStoreWithSelector2(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+  return React4.useMemo(() => {
+    return [settings, updateRoomNotificationSettings];
+  }, [settings, updateRoomNotificationSettings]);
+}
+function useUpdateRoomNotificationSettings() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (settings) => {
+      const optimisticUpdateId = nanoid3();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        id: optimisticUpdateId,
+        type: "update-notification-settings",
+        roomId: room.id,
+        settings
+      });
+      room[kInternal2].notifications.updateRoomNotificationSettings(settings).then(
+        (settings2) => {
+          store.set((state) => ({
+            ...state,
+            notificationSettings: {
+              [room.id]: settings2
+            },
+            optimisticUpdates: state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            )
+          }));
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new UpdateNotificationSettingsError(error, {
+            roomId: room.id
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function ensureNotServerSide() {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "You cannot use the Suspense version of this hook on the server side. Make sure to only call them on the client side.\nFor tips, see https://liveblocks.io/docs/api-reference/liveblocks-react#suspense-avoid-ssr"
+    );
+  }
+}
+function useSuspendUntilPresenceLoaded() {
+  const room = useRoom();
+  if (room.getSelf() !== null) {
+    return;
+  }
+  ensureNotServerSide();
+  throw new Promise((res) => {
+    room.events.self.subscribeOnce(() => res());
+    room.events.status.subscribeOnce(() => res());
+  });
+}
+function useSelfSuspense(selector, isEqual) {
+  useSuspendUntilPresenceLoaded();
+  return useSelf(
+    selector,
+    isEqual
+  );
+}
+function useOthersSuspense(selector, isEqual) {
+  useSuspendUntilPresenceLoaded();
+  return useOthers(
+    selector,
+    isEqual
+  );
+}
+function useOthersConnectionIdsSuspense() {
+  useSuspendUntilPresenceLoaded();
+  return useOthersConnectionIds();
+}
+function useOthersMappedSuspense(itemSelector, itemIsEqual) {
+  useSuspendUntilPresenceLoaded();
+  return useOthersMapped(itemSelector, itemIsEqual);
+}
+function useOtherSuspense(connectionId, selector, isEqual) {
+  useSuspendUntilPresenceLoaded();
+  return useOther(connectionId, selector, isEqual);
+}
+function useSuspendUntilStorageLoaded() {
+  const room = useRoom();
+  if (room.getStorageSnapshot() !== null) {
+    return;
+  }
+  ensureNotServerSide();
+  throw new Promise((res) => {
+    room.events.storageDidLoad.subscribeOnce(() => res());
+  });
+}
+function useStorageSuspense(selector, isEqual) {
+  useSuspendUntilStorageLoaded();
+  return useStorage(
+    selector,
+    isEqual
+  );
+}
+function useThreadsSuspense(options = {
+  query: { metadata: {} }
+}) {
+  const { scrollOnLoad = true } = options;
+  const client = useClient();
+  const room = useRoom();
+  const queryKey = React4.useMemo(
+    () => generateQueryKey(room.id, options.query),
+    [room, options]
+  );
+  const { store, getThreadsAndInboxNotifications } = getExtrasForClient2(client);
+  const query = store.get().queries[queryKey];
+  if (query === void 0 || query.isLoading) {
+    throw getThreadsAndInboxNotifications(room, queryKey, options);
+  }
+  if (query.error) {
+    throw query.error;
+  }
+  const selector = React4.useCallback(
+    (state2) => {
+      return {
+        threads: selectedThreads(room.id, state2, options),
+        isLoading: false
+      };
+    },
+    [room, queryKey]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  React4.useEffect(() => {
+    const { incrementQuerySubscribers } = getExtrasForClient2(client);
+    return incrementQuerySubscribers(queryKey);
+  }, [client, queryKey]);
+  const state = useSyncExternalStoreWithSelector2(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+  useScrollToCommentOnLoadEffect(scrollOnLoad, state);
+  return state;
+}
+function useRoomNotificationSettingsSuspense() {
+  const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
+  const client = useClient();
+  const room = useRoom();
+  const queryKey = makeNotificationSettingsQueryKey(room.id);
+  const { store, getInboxNotificationSettings } = getExtrasForClient2(client);
+  const query = store.get().queries[queryKey];
+  if (query === void 0 || query.isLoading) {
+    throw getInboxNotificationSettings(room, queryKey);
+  }
+  if (query.error) {
+    throw query.error;
+  }
+  const selector = React4.useCallback(
+    (state) => {
+      return {
+        isLoading: false,
+        settings: selectNotificationSettings(room.id, state)
+      };
+    },
+    [room]
+  );
+  const settings = useSyncExternalStoreWithSelector2(
+    store.subscribe,
+    store.get,
+    store.get,
+    selector
+  );
+  return React4.useMemo(() => {
+    return [settings, updateRoomNotificationSettings];
+  }, [settings, updateRoomNotificationSettings]);
+}
+function useRoomOrNull() {
+  return React4.useContext(RoomContext);
+}
+function createRoomContext(client) {
+  return getOrCreateRoomContextBundle(client);
+}
+function generateQueryKey(roomId, options) {
+  return `${roomId}-${stringify(options ?? {})}`;
+}
+var _RoomProvider = RoomProvider;
+var _useBroadcastEvent = useBroadcastEvent;
+var _useOthersListener = useOthersListener;
+var _useRoom = useRoom;
+var _useAddReaction = useAddReaction;
+var _useMutation = useMutation;
+var _useCreateThread = useCreateThread;
+var _useEditThreadMetadata = useEditThreadMetadata;
+var _useEventListener = useEventListener;
+var _useMyPresence = useMyPresence;
+var _useOthersMapped = useOthersMapped;
+var _useOthersMappedSuspense = useOthersMappedSuspense;
+var _useThreads = useThreads;
+var _useThreadsSuspense = useThreadsSuspense;
+var _useOther = useOther;
+var _useOthers = useOthers;
+var _useOtherSuspense = useOtherSuspense;
+var _useOthersSuspense = useOthersSuspense;
+var _useStorage = useStorage;
+var _useStorageSuspense = useStorageSuspense;
+var _useSelf = useSelf;
+var _useSelfSuspense = useSelfSuspense;
+var _useStorageRoot = useStorageRoot;
+var _useUpdateMyPresence = useUpdateMyPresence;
+
+export {
+  PKG_NAME,
+  PKG_VERSION,
+  PKG_FORMAT,
+  ClientSideSuspense,
+  ClientContext,
+  useClient,
+  LiveblocksProvider,
+  createLiveblocksContext,
+  useInboxNotifications,
+  useInboxNotificationsSuspense,
+  useMarkAllInboxNotificationsAsRead,
+  useMarkInboxNotificationAsRead,
+  useUnreadInboxNotificationsCount,
+  useUnreadInboxNotificationsCountSuspense,
+  useRoomInfo,
+  useRoomInfoSuspense,
+  __1,
+  __2,
+  __3,
+  CreateThreadError,
+  selectedThreads,
+  RoomContext,
+  useStatus,
+  useBatch,
+  useLostConnectionListener,
+  useErrorListener,
+  useHistory,
+  useUndo,
+  useRedo,
+  useCanUndo,
+  useCanRedo,
+  useOthersConnectionIds,
+  useCommentsErrorListener,
+  useCreateComment,
+  useEditComment,
+  useDeleteComment,
+  useRemoveReaction,
+  useMarkThreadAsRead,
+  useThreadSubscription,
+  useRoomNotificationSettings,
+  useUpdateRoomNotificationSettings,
+  useOthersConnectionIdsSuspense,
+  createRoomContext,
+  _RoomProvider,
+  _useBroadcastEvent,
+  _useOthersListener,
+  _useRoom,
+  _useAddReaction,
+  _useMutation,
+  _useCreateThread,
+  _useEditThreadMetadata,
+  _useEventListener,
+  _useMyPresence,
+  _useOthersMapped,
+  _useOthersMappedSuspense,
+  _useThreads,
+  _useThreadsSuspense,
+  _useOther,
+  _useOthers,
+  _useOtherSuspense,
+  _useOthersSuspense,
+  _useStorage,
+  _useStorageSuspense,
+  _useSelf,
+  _useSelfSuspense,
+  _useStorageRoot,
+  _useUpdateMyPresence
+};
+//# sourceMappingURL=chunk-HZXXTIZ4.mjs.map