@liveblocks/core 1.19.0-test1 → 2.0.0-alpha2

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.19.0-test1";
+var PKG_VERSION = "2.0.0-alpha2";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -362,23 +362,29 @@ var FSM = class {
   }
   onEnterAsync(nameOrPattern, promiseFn, onOK, onError) {
     return this.onEnter(nameOrPattern, () => {
-      let cancelled = false;
-      void promiseFn(this.currentContext.current).then(
+      const abortController = new AbortController();
+      const signal = abortController.signal;
+      let done = false;
+      void promiseFn(this.currentContext.current, signal).then(
         // On OK
         (data) => {
-          if (!cancelled) {
+          if (!signal.aborted) {
+            done = true;
             this.transition({ type: "ASYNC_OK", data }, onOK);
           }
         },
         // On Error
         (reason) => {
-          if (!cancelled) {
+          if (!signal.aborted) {
+            done = true;
             this.transition({ type: "ASYNC_ERROR", reason }, onError);
           }
         }
       );
       return () => {
-        cancelled = true;
+        if (!done) {
+          abortController.abort();
+        }
       };
     });
   }
@@ -652,6 +658,7 @@ var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
 
 // src/types/IWebSocket.ts
 var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_NORMAL"] = 1e3] = "CLOSE_NORMAL";
   WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
   WebsocketCloseCodes2[WebsocketCloseCodes2["UNEXPECTED_CONDITION"] = 1011] = "UNEXPECTED_CONDITION";
   WebsocketCloseCodes2[WebsocketCloseCodes2["TRY_AGAIN_LATER"] = 1013] = "TRY_AGAIN_LATER";
@@ -661,6 +668,8 @@ var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
   WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
   WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
   WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["ROOM_ID_UPDATED"] = 4006] = "ROOM_ID_UPDATED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["KICKED"] = 4100] = "KICKED";
   WebsocketCloseCodes2[WebsocketCloseCodes2["TOKEN_EXPIRED"] = 4109] = "TOKEN_EXPIRED";
   WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
   return WebsocketCloseCodes2;
@@ -679,22 +688,6 @@ function shouldRetryWithoutReauth(code) {
 function isIdle(status) {
   return status === "initial" || status === "disconnected";
 }
-function newToLegacyStatus(status) {
-  switch (status) {
-    case "connecting":
-      return "connecting";
-    case "connected":
-      return "open";
-    case "reconnecting":
-      return "unavailable";
-    case "disconnected":
-      return "failed";
-    case "initial":
-      return "closed";
-    default:
-      return "closed";
-  }
-}
 function toNewConnectionStatus(machine) {
   const state = machine.currentState;
   switch (state) {
@@ -728,16 +721,19 @@ var StopRetrying = class extends Error {
   }
 };
 var LiveblocksError = class extends Error {
+  /** @internal */
   constructor(message, code) {
     super(message);
     this.code = code;
   }
 };
-function nextBackoffDelay(currentDelay, delays = BACKOFF_DELAYS) {
+function nextBackoffDelay(currentDelay, delays) {
   return _nullishCoalesce(delays.find((delay) => delay > currentDelay), () => ( delays[delays.length - 1]));
 }
 function increaseBackoffDelay(context) {
-  context.patch({ backoffDelay: nextBackoffDelay(context.backoffDelay) });
+  context.patch({
+    backoffDelay: nextBackoffDelay(context.backoffDelay, BACKOFF_DELAYS)
+  });
 }
 function increaseBackoffDelayAggressively(context) {
   context.patch({
@@ -770,9 +766,13 @@ function logPrematureErrorOrCloseEvent(e) {
   };
 }
 function logCloseEvent(event) {
+  const details = [`code: ${event.code}`];
+  if (event.reason) {
+    details.push(`reason: ${event.reason}`);
+  }
   return (ctx) => {
     warn(
-      `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${ctx.backoffDelay}ms.`
+      `Connection to Liveblocks websocket server closed (${details.join(", ")}). Retrying in ${ctx.backoffDelay}ms.`
     );
   };
 }
@@ -884,8 +884,7 @@ function createConnectionStateMachine(delegates, options) {
     (okEvent) => ({
       target: "@connecting.busy",
       effect: assign({
-        authValue: okEvent.data,
-        backoffDelay: RESET_DELAY
+        authValue: okEvent.data
       })
     }),
     // Auth failed
@@ -942,14 +941,16 @@ function createConnectionStateMachine(delegates, options) {
     // When the "open" event happens, we're ready to transition to the
     // OK state. This is done by resolving the Promise.
     //
-    async (ctx) => {
+    async (ctx, signal) => {
       let capturedPrematureEvent = null;
+      let unconfirmedSocket = null;
       const connect$ = new Promise(
         (resolve, rej) => {
           if (ctx.authValue === null) {
             throw new Error("No auth authValue");
           }
           const socket = delegates.createSocket(ctx.authValue);
+          unconfirmedSocket = socket;
           function reject(event) {
             capturedPrematureEvent = event;
             socket.removeEventListener("message", onSocketMessage);
@@ -1005,12 +1006,18 @@ function createConnectionStateMachine(delegates, options) {
         //
         ([socket, unsub]) => {
           unsub();
+          if (signal.aborted) {
+            throw new Error("Aborted");
+          }
           if (capturedPrematureEvent) {
             throw capturedPrematureEvent;
           }
           return socket;
         }
-      );
+      ).catch((e) => {
+        teardownSocket(unconfirmedSocket);
+        throw e;
+      });
     },
     // Only transition to OK state after a successfully opened WebSocket connection
     (okEvent) => ({
@@ -1205,9 +1212,6 @@ var ManagedSocket = class {
     this.events = events;
     this.cleanups = cleanups;
   }
-  getLegacyStatus() {
-    return newToLegacyStatus(this.getStatus());
-  }
   getStatus() {
     try {
       return toNewConnectionStatus(this.machine);
@@ -1325,7 +1329,7 @@ function createAuthManager(authOptions) {
     }
     return false;
   }
-  function getCachedToken(requestedScope, roomId) {
+  function getCachedToken(requestOptions) {
     const now = Math.ceil(Date.now() / 1e3);
     for (let i = tokens.length - 1; i >= 0; i--) {
       const token = tokens[i];
@@ -1338,8 +1342,15 @@ function createAuthManager(authOptions) {
       if (token.parsed.k === "id" /* ID_TOKEN */) {
         return token;
       } else if (token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+        if (!requestOptions.roomId && Object.entries(token.parsed.perms).length === 0) {
+          return token;
+        }
         for (const [resource, scopes] of Object.entries(token.parsed.perms)) {
-          if (resource.includes("*") && roomId.startsWith(resource.replace("*", "")) || roomId === resource && hasCorrespondingScopes(requestedScope, scopes)) {
+          if (!requestOptions.roomId) {
+            if (resource.includes("*") && hasCorrespondingScopes(requestOptions.requestedScope, scopes)) {
+              return token;
+            }
+          } else if (resource.includes("*") && requestOptions.roomId.startsWith(resource.replace("*", "")) || requestOptions.roomId === resource && hasCorrespondingScopes(requestOptions.requestedScope, scopes)) {
             return token;
           }
         }
@@ -1347,7 +1358,7 @@ function createAuthManager(authOptions) {
     }
     return void 0;
   }
-  async function makeAuthRequest(roomId) {
+  async function makeAuthRequest(options) {
     const fetcher = _nullishCoalesce(_optionalChain([authOptions, 'access', _36 => _36.polyfills, 'optionalAccess', _37 => _37.fetch]), () => ( (typeof window === "undefined" ? void 0 : window.fetch)));
     if (authentication.type === "private") {
       if (fetcher === void 0) {
@@ -1356,7 +1367,7 @@ function createAuthManager(authOptions) {
         );
       }
       const response = await fetchAuthEndpoint(fetcher, authentication.url, {
-        room: roomId
+        room: options.roomId
       });
       const parsed = parseAuthToken(response.token);
       if (seenTokens.has(parsed.raw)) {
@@ -1367,10 +1378,11 @@ function createAuthManager(authOptions) {
       return parsed;
     }
     if (authentication.type === "custom") {
-      const response = await authentication.callback(roomId);
+      const response = await authentication.callback(options.roomId);
       if (response && typeof response === "object") {
         if (typeof response.token === "string") {
-          return parseAuthToken(response.token);
+          const parsed = parseAuthToken(response.token);
+          return parsed;
         } else if (typeof response.error === "string") {
           const reason = `Authentication failed: ${"reason" in response && typeof response.reason === "string" ? response.reason : "Forbidden"}`;
           if (response.error === "forbidden") {
@@ -1388,18 +1400,27 @@ function createAuthManager(authOptions) {
       "Unexpected authentication type. Must be private or custom."
     );
   }
-  async function getAuthValue(requestedScope, roomId) {
+  async function getAuthValue(requestOptions) {
     if (authentication.type === "public") {
       return { type: "public", publicApiKey: authentication.publicApiKey };
     }
-    const cachedToken = getCachedToken(requestedScope, roomId);
+    const cachedToken = getCachedToken(requestOptions);
     if (cachedToken !== void 0) {
       return { type: "secret", token: cachedToken };
     }
-    let currentPromise = requestPromises.get(roomId);
-    if (currentPromise === void 0) {
-      currentPromise = makeAuthRequest(roomId);
-      requestPromises.set(roomId, currentPromise);
+    let currentPromise;
+    if (requestOptions.roomId) {
+      currentPromise = requestPromises.get(requestOptions.roomId);
+      if (currentPromise === void 0) {
+        currentPromise = makeAuthRequest(requestOptions);
+        requestPromises.set(requestOptions.roomId, currentPromise);
+      }
+    } else {
+      currentPromise = requestPromises.get("liveblocks-user-token");
+      if (currentPromise === void 0) {
+        currentPromise = makeAuthRequest(requestOptions);
+        requestPromises.set("liveblocks-user-token", currentPromise);
+      }
     }
     try {
       const token = await currentPromise;
@@ -1412,7 +1433,11 @@ function createAuthManager(authOptions) {
       }
       return { type: "secret", token };
     } finally {
-      requestPromises.delete(roomId);
+      if (requestOptions.roomId) {
+        requestPromises.delete(requestOptions.roomId);
+      } else {
+        requestPromises.delete("liveblocks-user-token");
+      }
     }
   }
   return {
@@ -1501,6 +1526,9 @@ async function fetchAuthEndpoint(fetch2, endpoint, body) {
 // src/constants.ts
 var DEFAULT_BASE_URL = "https://api.liveblocks.io";
 
+// src/internal.ts
+var kInternal = Symbol();
+
 // src/devtools/bridge.ts
 var _bridgeActive = false;
 function activateBridge(allowed) {
@@ -1630,7 +1658,7 @@ function partialSyncStorage(room) {
   }
 }
 function partialSyncMe(room) {
-  const me = room.__internal.getSelf_forDevTools();
+  const me = room[kInternal].getSelf_forDevTools();
   if (me) {
     sendToPanel({
       msg: "room::sync::partial",
@@ -1640,7 +1668,7 @@ function partialSyncMe(room) {
   }
 }
 function partialSyncOthers(room) {
-  const others = room.__internal.getOthers_forDevTools();
+  const others = room[kInternal].getOthers_forDevTools();
   if (others) {
     sendToPanel({
       msg: "room::sync::partial",
@@ -1651,8 +1679,8 @@ function partialSyncOthers(room) {
 }
 function fullSync(room) {
   const root = room.getStorageSnapshot();
-  const me = room.__internal.getSelf_forDevTools();
-  const others = room.__internal.getOthers_forDevTools();
+  const me = room[kInternal].getSelf_forDevTools();
+  const others = room[kInternal].getOthers_forDevTools();
   room.fetchYDoc("");
   sendToPanel({
     msg: "room::sync::full",
@@ -1711,6 +1739,183 @@ function unlinkDevTools(roomId) {
   });
 }
 
+// src/lib/stringify.ts
+function stringify(object, ...args) {
+  if (typeof object !== "object" || object === null || Array.isArray(object)) {
+    return JSON.stringify(object, ...args);
+  }
+  const sortedObject = Object.keys(object).sort().reduce(
+    (sortedObject2, key) => {
+      sortedObject2[key] = object[key];
+      return sortedObject2;
+    },
+    {}
+  );
+  return JSON.stringify(sortedObject, ...args);
+}
+
+// src/lib/batch.ts
+var DEFAULT_SIZE = 50;
+var DEFAULT_DELAY = 100;
+var noop = () => {
+};
+var BatchCall = class {
+  constructor(args) {
+    this.resolve = noop;
+    this.reject = noop;
+    this.promise = new Promise(noop);
+    this.args = args;
+  }
+};
+var Batch = class {
+  constructor(callback, options) {
+    this.queue = [];
+    this.error = false;
+    this.callback = callback;
+    this.size = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.size]), () => ( DEFAULT_SIZE));
+    this.delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.delay]), () => ( DEFAULT_DELAY));
+  }
+  clearDelayTimeout() {
+    if (this.delayTimeoutId !== void 0) {
+      clearTimeout(this.delayTimeoutId);
+      this.delayTimeoutId = void 0;
+    }
+  }
+  schedule() {
+    if (this.queue.length === this.size) {
+      void this.flush();
+    } else if (this.queue.length === 1) {
+      this.clearDelayTimeout();
+      this.delayTimeoutId = setTimeout(() => void this.flush(), this.delay);
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const calls = this.queue.splice(0);
+    const args = calls.map((call) => call.args);
+    try {
+      const results = await this.callback(args);
+      this.error = false;
+      calls.forEach((call, index) => {
+        const result = _optionalChain([results, 'optionalAccess', _46 => _46[index]]);
+        if (!Array.isArray(results)) {
+          call.reject(new Error("Callback must return an array."));
+        } else if (calls.length !== results.length) {
+          call.reject(
+            new Error(
+              `Callback must return an array of the same length as the number of provided items. Expected ${calls.length}, but got ${results.length}.`
+            )
+          );
+        } else if (result instanceof Error) {
+          call.reject(result);
+        } else {
+          call.resolve(result);
+        }
+      });
+    } catch (error3) {
+      this.error = true;
+      calls.forEach((call) => {
+        call.reject(error3);
+      });
+    }
+  }
+  get(...args) {
+    const existingCall = this.queue.find(
+      (call2) => stringify(call2.args) === stringify(args)
+    );
+    if (existingCall) {
+      return existingCall.promise;
+    }
+    const call = new BatchCall(args);
+    call.promise = new Promise((resolve, reject) => {
+      call.resolve = resolve;
+      call.reject = reject;
+    });
+    this.queue.push(call);
+    this.schedule();
+    return call.promise;
+  }
+  clear() {
+    this.queue = [];
+    this.error = false;
+    this.clearDelayTimeout();
+  }
+};
+function createBatchStore(callback, options) {
+  const batch = new Batch(callback, options);
+  const cache = /* @__PURE__ */ new Map();
+  const eventSource2 = makeEventSource();
+  function getCacheKey(args) {
+    return stringify(args);
+  }
+  function setStateAndNotify(cacheKey, state) {
+    if (state) {
+      cache.set(cacheKey, state);
+    } else {
+      cache.delete(cacheKey);
+    }
+    eventSource2.notify(state);
+  }
+  async function get(...args) {
+    const cacheKey = getCacheKey(args);
+    if (cache.has(cacheKey)) {
+      return;
+    }
+    try {
+      setStateAndNotify(cacheKey, { isLoading: true });
+      const result = await batch.get(...args);
+      setStateAndNotify(cacheKey, { isLoading: false, data: result });
+    } catch (error3) {
+      setStateAndNotify(cacheKey, {
+        isLoading: false,
+        error: error3
+      });
+    }
+  }
+  function getState(...args) {
+    const cacheKey = getCacheKey(args);
+    return cache.get(cacheKey);
+  }
+  return {
+    ...eventSource2,
+    get,
+    getState
+  };
+}
+
+// src/lib/create-store.ts
+function createStore(initialState) {
+  let state = initialState;
+  const subscribers = /* @__PURE__ */ new Set();
+  function get() {
+    return state;
+  }
+  function set(callback) {
+    const newState = callback(state);
+    if (state === newState) {
+      return;
+    }
+    state = newState;
+    for (const subscriber of subscribers) {
+      subscriber(state);
+    }
+  }
+  function subscribe(callback) {
+    subscribers.add(callback);
+    callback(state);
+    return () => {
+      subscribers.delete(callback);
+    };
+  }
+  return {
+    get,
+    set,
+    subscribe
+  };
+}
+
 // src/lib/deprecation.ts
 var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
 function deprecate(message, key = message) {
@@ -1744,390 +1949,144 @@ function errorIf(condition, message) {
   }
 }
 
-// src/comments/comment-body.ts
-function isCommentBodyParagraph(element) {
-  return "type" in element && element.type === "mention";
-}
-function isCommentBodyText(element) {
-  return "text" in element && typeof element.text === "string";
-}
-function isCommentBodyMention(element) {
-  return "type" in element && element.type === "mention";
-}
-function isCommentBodyLink(element) {
-  return "type" in element && element.type === "link";
-}
-var commentBodyElementsGuards = {
-  paragraph: isCommentBodyParagraph,
-  text: isCommentBodyText,
-  link: isCommentBodyLink,
-  mention: isCommentBodyMention
-};
-var commentBodyElementsTypes = {
-  paragraph: "block",
-  text: "inline",
-  link: "inline",
-  mention: "inline"
-};
-function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
-  if (!body || !_optionalChain([body, 'optionalAccess', _44 => _44.content])) {
-    return;
-  }
-  const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
-  const type = element ? commentBodyElementsTypes[element] : "all";
-  const guard = element ? commentBodyElementsGuards[element] : () => true;
-  const visitor = typeof elementOrVisitor === "function" ? elementOrVisitor : possiblyVisitor;
-  for (const block of body.content) {
-    if (type === "all" || type === "block") {
-      if (guard(block)) {
-        _optionalChain([visitor, 'optionalCall', _45 => _45(block)]);
-      }
-    }
-    if (type === "all" || type === "inline") {
-      for (const inline of block.children) {
-        if (guard(inline)) {
-          _optionalChain([visitor, 'optionalCall', _46 => _46(inline)]);
-        }
-      }
-    }
+// src/convert-plain-data.ts
+function convertToCommentData(data) {
+  const editedAt = data.editedAt ? new Date(data.editedAt) : void 0;
+  const createdAt = new Date(data.createdAt);
+  const reactions = data.reactions.map((reaction) => ({
+    ...reaction,
+    createdAt: new Date(reaction.createdAt)
+  }));
+  if (data.body) {
+    return {
+      ...data,
+      reactions,
+      createdAt,
+      editedAt
+    };
+  } else {
+    const deletedAt = new Date(data.deletedAt);
+    return {
+      ...data,
+      reactions,
+      createdAt,
+      editedAt,
+      deletedAt
+    };
   }
 }
-function getMentionedIdsFromCommentBody(body) {
-  const mentionedIds = /* @__PURE__ */ new Set();
-  traverseCommentBody(
-    body,
-    "mention",
-    (mention) => mentionedIds.add(mention.id)
+function convertToThreadData(data) {
+  const updatedAt = data.updatedAt ? new Date(data.updatedAt) : void 0;
+  const createdAt = new Date(data.createdAt);
+  const comments = data.comments.map(
+    (comment) => convertToCommentData(comment)
   );
-  return Array.from(mentionedIds);
+  return {
+    ...data,
+    createdAt,
+    updatedAt,
+    comments
+  };
 }
-async function resolveUsersInCommentBody(body, resolveUsers) {
-  const resolvedUsers = /* @__PURE__ */ new Map();
-  if (!resolveUsers) {
-    return resolvedUsers;
-  }
-  const userIds = getMentionedIdsFromCommentBody(body);
-  const users = await resolveUsers({
-    userIds
-  });
-  for (const [index, userId] of userIds.entries()) {
-    const user = _optionalChain([users, 'optionalAccess', _47 => _47[index]]);
-    if (user) {
-      resolvedUsers.set(userId, user);
-    }
+function convertToCommentUserReaction(data) {
+  return {
+    ...data,
+    createdAt: new Date(data.createdAt)
+  };
+}
+function convertToInboxNotificationData(data) {
+  const notifiedAt = new Date(data.notifiedAt);
+  const readAt = data.readAt ? new Date(data.readAt) : null;
+  if ("activities" in data) {
+    const activities = data.activities.map((activity) => ({
+      ...activity,
+      createdAt: new Date(activity.createdAt)
+    }));
+    return {
+      ...data,
+      notifiedAt,
+      readAt,
+      activities
+    };
   }
-  return resolvedUsers;
+  return {
+    ...data,
+    notifiedAt,
+    readAt
+  };
 }
-var htmlEscapables = {
-  "&": "&",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;"
-};
-var htmlEscapablesRegex = new RegExp(
-  Object.keys(htmlEscapables).map((entity) => `\\${entity}`).join("|"),
-  "g"
-);
-function htmlSafe(value) {
-  return new HtmlSafeString([String(value)], []);
+function convertToThreadDeleteInfo(data) {
+  const deletedAt = new Date(data.deletedAt);
+  return {
+    ...data,
+    deletedAt
+  };
 }
-function joinHtml(strings) {
-  if (strings.length <= 0) {
-    return new HtmlSafeString([""], []);
-  }
-  return new HtmlSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
-  );
+function convertToInboxNotificationDeleteInfo(data) {
+  const deletedAt = new Date(data.deletedAt);
+  return {
+    ...data,
+    deletedAt
+  };
 }
-function escapeHtml(value) {
-  if (value instanceof HtmlSafeString) {
-    return value.toString();
-  }
-  if (Array.isArray(value)) {
-    return joinHtml(value).toString();
+
+// src/lib/url.ts
+function toURLSearchParams(params) {
+  const result = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      result.set(key, value.toString());
+    }
   }
-  return String(value).replace(
-    htmlEscapablesRegex,
-    (character) => htmlEscapables[character]
-  );
+  return result;
 }
-var HtmlSafeString = class {
-  constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
+function urljoin(baseUrl, path, params) {
+  const url = new URL(path, baseUrl);
+  if (params !== void 0) {
+    url.search = (params instanceof URLSearchParams ? params : toURLSearchParams(params)).toString();
   }
-  toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeHtml(nn(this._values[i - 1])) + str;
+  return url.toString();
+}
+
+// src/notifications.ts
+var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY = 50;
+function createNotificationsApi({
+  baseUrl,
+  authManager,
+  currentUserIdStore,
+  fetcher
+}) {
+  async function fetchJson(endpoint, options, params) {
+    const authValue = await authManager.getAuthValue({
+      requestedScope: "comments:read"
     });
-  }
-};
-function html(strings, ...values) {
-  return new HtmlSafeString(strings, values);
-}
-var markdownEscapables = {
-  _: "\\_",
-  "*": "\\*",
-  "#": "\\#",
-  "`": "\\`",
-  "~": "\\~",
-  "!": "\\!",
-  "|": "\\|",
-  "(": "\\(",
-  ")": "\\)",
-  "{": "\\{",
-  "}": "\\}",
-  "[": "\\[",
-  "]": "\\]"
-};
-var markdownEscapablesRegex = new RegExp(
-  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
-  "g"
-);
-function joinMarkdown(strings) {
-  if (strings.length <= 0) {
-    return new MarkdownSafeString([""], []);
-  }
-  return new MarkdownSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
-  );
-}
-function escapeMarkdown(value) {
-  if (value instanceof MarkdownSafeString) {
-    return value.toString();
-  }
-  if (Array.isArray(value)) {
-    return joinMarkdown(value).toString();
-  }
-  return String(value).replace(
-    markdownEscapablesRegex,
-    (character) => markdownEscapables[character]
-  );
-}
-var MarkdownSafeString = class {
-  constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
-  }
-  toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeMarkdown(nn(this._values[i - 1])) + str;
-    });
-  }
-};
-function markdown(strings, ...values) {
-  return new MarkdownSafeString(strings, values);
-}
-function toAbsoluteUrl(url) {
-  if (url.startsWith("http://") || url.startsWith("https://")) {
-    return url;
-  } else if (url.startsWith("www.")) {
-    return "https://" + url;
-  }
-  return;
-}
-var stringifyCommentBodyPlainElements = {
-  paragraph: ({ children }) => children,
-  text: ({ element }) => element.text,
-  link: ({ element }) => element.url,
-  mention: ({ element, user }) => {
-    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _48 => _48.name]), () => ( element.id))}`;
-  }
-};
-var stringifyCommentBodyHtmlElements = {
-  paragraph: ({ children }) => {
-    return children ? html`<p>${htmlSafe(children)}</p>` : children;
-  },
-  text: ({ element }) => {
-    let children = element.text;
-    if (!children) {
-      return children;
-    }
-    if (element.bold) {
-      children = html`<strong>${children}</strong>`;
-    }
-    if (element.italic) {
-      children = html`<em>${children}</em>`;
-    }
-    if (element.strikethrough) {
-      children = html`<s>${children}</s>`;
-    }
-    if (element.code) {
-      children = html`<code>${children}</code>`;
-    }
-    return children;
-  },
-  link: ({ element, href }) => {
-    return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.url}</a>`;
-  },
-  mention: ({ element, user }) => {
-    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _49 => _49.name]), () => ( element.id))}</span>`;
-  }
-};
-var stringifyCommentBodyMarkdownElements = {
-  paragraph: ({ children }) => {
-    return children;
-  },
-  text: ({ element }) => {
-    let children = element.text;
-    if (!children) {
-      return children;
-    }
-    if (element.bold) {
-      children = markdown`**${children}**`;
+    if (authValue.type === "secret" && authValue.token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+      const userId = authValue.token.parsed.uid;
+      currentUserIdStore.set(() => userId);
     }
-    if (element.italic) {
-      children = markdown`_${children}_`;
-    }
-    if (element.strikethrough) {
-      children = markdown`~~${children}~~`;
-    }
-    if (element.code) {
-      children = markdown`\`${children}\``;
-    }
-    return children;
-  },
-  link: ({ element, href }) => {
-    return markdown`[${element.url}](${href})`;
-  },
-  mention: ({ element, user }) => {
-    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _50 => _50.name]), () => ( element.id))}`;
-  }
-};
-async function stringifyCommentBody(body, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.format]), () => ( "plain"));
-  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
-  const elements = {
-    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ..._optionalChain([options, 'optionalAccess', _53 => _53.elements])
-  };
-  const resolvedUsers = await resolveUsersInCommentBody(
-    body,
-    _optionalChain([options, 'optionalAccess', _54 => _54.resolveUsers])
-  );
-  const blocks = body.content.flatMap((block, blockIndex) => {
-    switch (block.type) {
-      case "paragraph": {
-        const inlines = block.children.flatMap((inline, inlineIndex) => {
-          if (isCommentBodyMention(inline)) {
-            return inline.id ? [
-              elements.mention(
-                {
-                  element: inline,
-                  user: resolvedUsers.get(inline.id)
-                },
-                inlineIndex
-              )
-            ] : [];
-          }
-          if (isCommentBodyLink(inline)) {
-            return [
-              elements.link(
-                {
-                  element: inline,
-                  href: _nullishCoalesce(toAbsoluteUrl(inline.url), () => ( inline.url))
-                },
-                inlineIndex
-              )
-            ];
-          }
-          if (isCommentBodyText(inline)) {
-            return [elements.text({ element: inline }, inlineIndex)];
-          }
-          return [];
-        });
-        return [
-          elements.paragraph(
-            { element: block, children: inlines.join("") },
-            blockIndex
-          )
-        ];
+    const url = urljoin(baseUrl, `/v2/c${endpoint}`, params);
+    const response = await fetcher(url.toString(), {
+      ...options,
+      headers: {
+        ..._optionalChain([options, 'optionalAccess', _47 => _47.headers]),
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
       }
-      default:
-        return [];
-    }
-  });
-  return blocks.join(separator);
-}
-function convertToCommentData(data) {
-  const editedAt = data.editedAt ? new Date(data.editedAt) : void 0;
-  const createdAt = new Date(data.createdAt);
-  const reactions = data.reactions.map((reaction) => ({
-    ...reaction,
-    createdAt: new Date(reaction.createdAt)
-  }));
-  if (data.body) {
-    return {
-      ...data,
-      reactions,
-      createdAt,
-      editedAt
-    };
-  } else {
-    const deletedAt = new Date(data.deletedAt);
-    return {
-      ...data,
-      reactions,
-      createdAt,
-      editedAt,
-      deletedAt
-    };
-  }
-}
-function convertToThreadData(data) {
-  const updatedAt = data.updatedAt ? new Date(data.updatedAt) : void 0;
-  const createdAt = new Date(data.createdAt);
-  const comments = data.comments.map(
-    (comment) => convertToCommentData(comment)
-  );
-  return {
-    ...data,
-    createdAt,
-    updatedAt,
-    comments
-  };
-}
-function convertToCommentUserReaction(data) {
-  return {
-    ...data,
-    createdAt: new Date(data.createdAt)
-  };
-}
-
-// src/comments/index.ts
-function getAuthBearerHeaderFromAuthValue(authValue) {
-  if (authValue.type === "public") {
-    return authValue.publicApiKey;
-  } else {
-    return authValue.token.raw;
-  }
-}
-var CommentsApiError = class extends Error {
-  constructor(message, status, details) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.details = details;
-  }
-};
-function createCommentsApi(roomId, getAuthValue, config) {
-  async function fetchJson(endpoint, options) {
-    const response = await fetchApi(roomId, endpoint, options);
+    });
     if (!response.ok) {
       if (response.status >= 400 && response.status < 600) {
         let error3;
         try {
           const errorBody = await response.json();
-          error3 = new CommentsApiError(
+          error3 = new NotificationsApiError(
             errorBody.message,
             response.status,
             errorBody
           );
         } catch (e3) {
-          error3 = new CommentsApiError(response.statusText, response.status);
+          error3 = new NotificationsApiError(
+            response.statusText,
+            response.status
+          );
         }
         throw error3;
       }
@@ -2140,175 +2099,65 @@ function createCommentsApi(roomId, getAuthValue, config) {
     }
     return body;
   }
-  async function fetchApi(roomId2, endpoint, options) {
-    const authValue = await getAuthValue();
-    const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(roomId2)}${endpoint}`,
-      config.baseUrl
-    );
-    return await fetch(url.toString(), {
-      ...options,
-      headers: {
-        ..._optionalChain([options, 'optionalAccess', _55 => _55.headers]),
-        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
-      }
+  async function getInboxNotifications(options) {
+    const json = await fetchJson("/inbox-notifications", void 0, {
+      limit: _optionalChain([options, 'optionalAccess', _48 => _48.limit]),
+      since: _optionalChain([options, 'optionalAccess', _49 => _49.since, 'optionalAccess', _50 => _50.toISOString, 'call', _51 => _51()])
     });
-  }
-  async function getThreads(options) {
-    const response = await fetchApi(roomId, "/threads/search", {
-      body: JSON.stringify({
-        ..._optionalChain([options, 'optionalAccess', _56 => _56.query, 'optionalAccess', _57 => _57.metadata]) && { metadata: options.query.metadata }
-      }),
-      headers: {
-        "Content-Type": "application/json"
-      },
-      method: "POST"
-    });
-    if (response.ok) {
-      const json = await response.json();
-      return json.data.map((thread) => convertToThreadData(thread));
-    } else if (response.status === 404) {
-      return [];
-    } else {
-      throw new Error("There was an error while getting threads.");
-    }
-  }
-  async function createThread({
-    metadata,
-    body,
-    commentId,
-    threadId
-  }) {
-    const thread = await fetchJson(
-      "/threads",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: threadId,
-          comment: {
-            id: commentId,
-            body
-          },
-          metadata
-        })
-      }
-    );
-    return convertToThreadData(thread);
-  }
-  async function editThreadMetadata({
-    metadata,
-    threadId
-  }) {
-    return await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
-    );
-  }
-  async function createComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: commentId,
-          body
-        })
+    return {
+      threads: json.threads.map((thread) => convertToThreadData(thread)),
+      inboxNotifications: json.inboxNotifications.map(
+        (notification) => convertToInboxNotificationData(notification)
+      ),
+      deletedThreads: json.deletedThreads.map(
+        (info) => convertToThreadDeleteInfo(info)
+      ),
+      deletedInboxNotifications: json.deletedInboxNotifications.map(
+        (info) => convertToInboxNotificationDeleteInfo(info)
+      ),
+      meta: {
+        requestedAt: new Date(json.meta.requestedAt)
       }
-    );
-    return convertToCommentData(comment);
+    };
   }
-  async function editComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          body
-        })
-      }
-    );
-    return convertToCommentData(comment);
+  async function getUnreadInboxNotificationsCount() {
+    const { count } = await fetchJson("/inbox-notifications/count");
+    return count;
   }
-  async function deleteComment({
-    threadId,
-    commentId
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "DELETE"
-      }
-    );
+  async function markAllInboxNotificationsAsRead() {
+    await fetchJson("/inbox-notifications/read", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ inboxNotificationIds: "all" })
+    });
   }
-  async function addReaction({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    const reaction = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ emoji })
-      }
-    );
-    return convertToCommentUserReaction(reaction);
+  async function markInboxNotificationsAsRead(inboxNotificationIds) {
+    await fetchJson("/inbox-notifications/read", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ inboxNotificationIds })
+    });
   }
-  async function removeReaction({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions/${encodeURIComponent(emoji)}`,
-      {
-        method: "DELETE"
-      }
-    );
+  const batchedMarkInboxNotificationsAsRead = new Batch(
+    async (batchedInboxNotificationIds) => {
+      const inboxNotificationIds = batchedInboxNotificationIds.flat();
+      await markInboxNotificationsAsRead(inboxNotificationIds);
+      return inboxNotificationIds;
+    },
+    { delay: MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY }
+  );
+  async function markInboxNotificationAsRead(inboxNotificationId) {
+    await batchedMarkInboxNotificationsAsRead.get(inboxNotificationId);
   }
   return {
-    getThreads,
-    createThread,
-    editThreadMetadata,
-    createComment,
-    editComment,
-    deleteComment,
-    addReaction,
-    removeReaction
+    getInboxNotifications,
+    getUnreadInboxNotificationsCount,
+    markAllInboxNotificationsAsRead,
+    markInboxNotificationAsRead
   };
 }
 
@@ -2452,6 +2301,14 @@ var OpCode = /* @__PURE__ */ ((OpCode2) => {
   OpCode2[OpCode2["CREATE_REGISTER"] = 8] = "CREATE_REGISTER";
   return OpCode2;
 })(OpCode || {});
+function ackOp(opId) {
+  return {
+    type: 5 /* DELETE_CRDT */,
+    id: "ACK",
+    // (H)ACK
+    opId
+  };
+}
 function isAckOp(op) {
   return op.type === 5 /* DELETE_CRDT */ && op.id === "ACK";
 }
@@ -2677,7 +2534,7 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
     return [
       {
         type: 8 /* CREATE_REGISTER */,
-        opId: _optionalChain([pool, 'optionalAccess', _58 => _58.generateOpId, 'call', _59 => _59()]),
+        opId: _optionalChain([pool, 'optionalAccess', _52 => _52.generateOpId, 'call', _53 => _53()]),
         id: this._id,
         parentId,
         parentKey,
@@ -2779,7 +2636,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _60 => _60.generateOpId, 'call', _61 => _61()]),
+      opId: _optionalChain([pool, 'optionalAccess', _54 => _54.generateOpId, 'call', _55 => _55()]),
       type: 2 /* CREATE_LIST */,
       parentId,
       parentKey
@@ -3056,7 +2913,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applyInsertUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _62 => _62._pool, 'optionalAccess', _63 => _63.getNode, 'call', _64 => _64(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _56 => _56._pool, 'optionalAccess', _57 => _57.getNode, 'call', _58 => _58(id)]) !== void 0) {
       return { modified: false };
     }
     child._attach(id, nn(this._pool));
@@ -3064,8 +2921,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = _optionalChain([this, 'access', _65 => _65._items, 'access', _66 => _66[existingItemIndex], 'optionalAccess', _67 => _67._parentPos]);
-      const after2 = _optionalChain([this, 'access', _68 => _68._items, 'access', _69 => _69[existingItemIndex + 1], 'optionalAccess', _70 => _70._parentPos]);
+      const before2 = _optionalChain([this, 'access', _59 => _59._items, 'access', _60 => _60[existingItemIndex], 'optionalAccess', _61 => _61._parentPos]);
+      const after2 = _optionalChain([this, 'access', _62 => _62._items, 'access', _63 => _63[existingItemIndex + 1], 'optionalAccess', _64 => _64._parentPos]);
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
@@ -3080,7 +2937,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applySetUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _71 => _71._pool, 'optionalAccess', _72 => _72.getNode, 'call', _73 => _73(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _65 => _65._pool, 'optionalAccess', _66 => _66.getNode, 'call', _67 => _67(id)]) !== void 0) {
       return { modified: false };
     }
     this._unacknowledgedSets.set(key, nn(op.opId));
@@ -3202,7 +3059,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     } else {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _74 => _74._items, 'access', _75 => _75[existingItemIndex + 1], 'optionalAccess', _76 => _76._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _68 => _68._items, 'access', _69 => _69[existingItemIndex + 1], 'optionalAccess', _70 => _70._parentPos]))
       );
       const previousIndex = this._items.indexOf(child);
       child._setParentLink(this, newKey);
@@ -3228,7 +3085,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _77 => _77._items, 'access', _78 => _78[existingItemIndex + 1], 'optionalAccess', _79 => _79._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _71 => _71._items, 'access', _72 => _72[existingItemIndex + 1], 'optionalAccess', _73 => _73._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -3247,7 +3104,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _80 => _80._items, 'access', _81 => _81[existingItemIndex + 1], 'optionalAccess', _82 => _82._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _74 => _74._items, 'access', _75 => _75[existingItemIndex + 1], 'optionalAccess', _76 => _76._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -3275,7 +3132,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (existingItemIndex !== -1) {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _83 => _83._items, 'access', _84 => _84[existingItemIndex + 1], 'optionalAccess', _85 => _85._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _77 => _77._items, 'access', _78 => _78[existingItemIndex + 1], 'optionalAccess', _79 => _79._parentPos]))
       );
     }
     child._setParentLink(this, newKey);
@@ -3333,7 +3190,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    _optionalChain([this, 'access', _86 => _86._pool, 'optionalAccess', _87 => _87.assertStorageIsWritable, 'call', _88 => _88()]);
+    _optionalChain([this, 'access', _80 => _80._pool, 'optionalAccess', _81 => _81.assertStorageIsWritable, 'call', _82 => _82()]);
     return this.insert(element, this.length);
   }
   /**
@@ -3342,7 +3199,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
-    _optionalChain([this, 'access', _89 => _89._pool, 'optionalAccess', _90 => _90.assertStorageIsWritable, 'call', _91 => _91()]);
+    _optionalChain([this, 'access', _83 => _83._pool, 'optionalAccess', _84 => _84.assertStorageIsWritable, 'call', _85 => _85()]);
     if (index < 0 || index > this._items.length) {
       throw new Error(
         `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
@@ -3372,7 +3229,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param targetIndex The index where the element should be after moving.
    */
   move(index, targetIndex) {
-    _optionalChain([this, 'access', _92 => _92._pool, 'optionalAccess', _93 => _93.assertStorageIsWritable, 'call', _94 => _94()]);
+    _optionalChain([this, 'access', _86 => _86._pool, 'optionalAccess', _87 => _87.assertStorageIsWritable, 'call', _88 => _88()]);
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
@@ -3430,7 +3287,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index of the element to delete
    */
   delete(index) {
-    _optionalChain([this, 'access', _95 => _95._pool, 'optionalAccess', _96 => _96.assertStorageIsWritable, 'call', _97 => _97()]);
+    _optionalChain([this, 'access', _89 => _89._pool, 'optionalAccess', _90 => _90.assertStorageIsWritable, 'call', _91 => _91()]);
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -3463,7 +3320,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   clear() {
-    _optionalChain([this, 'access', _98 => _98._pool, 'optionalAccess', _99 => _99.assertStorageIsWritable, 'call', _100 => _100()]);
+    _optionalChain([this, 'access', _92 => _92._pool, 'optionalAccess', _93 => _93.assertStorageIsWritable, 'call', _94 => _94()]);
     if (this._pool) {
       const ops = [];
       const reverseOps = [];
@@ -3497,7 +3354,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   set(index, item) {
-    _optionalChain([this, 'access', _101 => _101._pool, 'optionalAccess', _102 => _102.assertStorageIsWritable, 'call', _103 => _103()]);
+    _optionalChain([this, 'access', _95 => _95._pool, 'optionalAccess', _96 => _96.assertStorageIsWritable, 'call', _97 => _97()]);
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -3645,7 +3502,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _shiftItemPosition(index, key) {
     const shiftedPosition = makePosition(
       key,
-      this._items.length > index + 1 ? _optionalChain([this, 'access', _104 => _104._items, 'access', _105 => _105[index + 1], 'optionalAccess', _106 => _106._parentPos]) : void 0
+      this._items.length > index + 1 ? _optionalChain([this, 'access', _98 => _98._items, 'access', _99 => _99[index + 1], 'optionalAccess', _100 => _100._parentPos]) : void 0
     );
     this._items[index]._setParentLink(this, shiftedPosition);
   }
@@ -3774,7 +3631,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _107 => _107.generateOpId, 'call', _108 => _108()]),
+      opId: _optionalChain([pool, 'optionalAccess', _101 => _101.generateOpId, 'call', _102 => _102()]),
       type: 7 /* CREATE_MAP */,
       parentId,
       parentKey
@@ -3921,7 +3778,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @param value The value of the element to add. Should be serializable to JSON.
    */
   set(key, value) {
-    _optionalChain([this, 'access', _109 => _109._pool, 'optionalAccess', _110 => _110.assertStorageIsWritable, 'call', _111 => _111()]);
+    _optionalChain([this, 'access', _103 => _103._pool, 'optionalAccess', _104 => _104.assertStorageIsWritable, 'call', _105 => _105()]);
     const oldValue = this._map.get(key);
     if (oldValue) {
       oldValue._detach();
@@ -3967,7 +3824,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @returns true if an element existed and has been removed, or false if the element does not exist.
    */
   delete(key) {
-    _optionalChain([this, 'access', _112 => _112._pool, 'optionalAccess', _113 => _113.assertStorageIsWritable, 'call', _114 => _114()]);
+    _optionalChain([this, 'access', _106 => _106._pool, 'optionalAccess', _107 => _107.assertStorageIsWritable, 'call', _108 => _108()]);
     const item = this._map.get(key);
     if (item === void 0) {
       return false;
@@ -4097,19 +3954,6 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
 
 // src/crdts/LiveObject.ts
 var LiveObject = class _LiveObject extends AbstractCrdt {
-  constructor(obj = {}) {
-    super();
-    this._propToLastUpdate = /* @__PURE__ */ new Map();
-    for (const key in obj) {
-      const value = obj[key];
-      if (value === void 0) {
-        continue;
-      } else if (isLiveNode(value)) {
-        value._setParentLink(this, key);
-      }
-    }
-    this._map = new Map(Object.entries(obj));
-  }
   /** @internal */
   static _buildRootAndParentToChildren(items) {
     const parentToChildren = /* @__PURE__ */ new Map();
@@ -4141,12 +3985,24 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       pool
     );
   }
+  constructor(obj = {}) {
+    super();
+    this._propToLastUpdate = /* @__PURE__ */ new Map();
+    const o = compactObject(obj);
+    for (const key of Object.keys(o)) {
+      const value = o[key];
+      if (isLiveNode(value)) {
+        value._setParentLink(this, key);
+      }
+    }
+    this._map = new Map(Object.entries(o));
+  }
   /** @internal */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
     }
-    const opId = _optionalChain([pool, 'optionalAccess', _115 => _115.generateOpId, 'call', _116 => _116()]);
+    const opId = _optionalChain([pool, 'optionalAccess', _109 => _109.generateOpId, 'call', _110 => _110()]);
     const ops = [];
     const op = {
       type: 4 /* CREATE_OBJECT */,
@@ -4424,7 +4280,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param value The value of the property to add
    */
   set(key, value) {
-    _optionalChain([this, 'access', _117 => _117._pool, 'optionalAccess', _118 => _118.assertStorageIsWritable, 'call', _119 => _119()]);
+    _optionalChain([this, 'access', _111 => _111._pool, 'optionalAccess', _112 => _112.assertStorageIsWritable, 'call', _113 => _113()]);
     this.update({ [key]: value });
   }
   /**
@@ -4439,7 +4295,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param key The key of the property to delete
    */
   delete(key) {
-    _optionalChain([this, 'access', _120 => _120._pool, 'optionalAccess', _121 => _121.assertStorageIsWritable, 'call', _122 => _122()]);
+    _optionalChain([this, 'access', _114 => _114._pool, 'optionalAccess', _115 => _115.assertStorageIsWritable, 'call', _116 => _116()]);
     const keyAsString = key;
     const oldValue = this._map.get(keyAsString);
     if (oldValue === void 0) {
@@ -4492,7 +4348,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param patch The object used to overrides properties
    */
   update(patch) {
-    _optionalChain([this, 'access', _123 => _123._pool, 'optionalAccess', _124 => _124.assertStorageIsWritable, 'call', _125 => _125()]);
+    _optionalChain([this, 'access', _117 => _117._pool, 'optionalAccess', _118 => _118.assertStorageIsWritable, 'call', _119 => _119()]);
     if (this._pool === void 0 || this._id === void 0) {
       for (const key in patch) {
         const newValue = patch[key];
@@ -4886,6 +4742,115 @@ function isJsonObject(data) {
   return !isJsonScalar(data) && !isJsonArray(data);
 }
 
+// src/lib/objectToQuery.ts
+var identifierRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function objectToQuery(obj) {
+  let filterList = [];
+  const entries2 = Object.entries(obj);
+  const keyValuePairs = [];
+  const keyValuePairsWithOperator = [];
+  const indexedKeys = [];
+  entries2.forEach(([key, value]) => {
+    if (!identifierRegex.test(key)) {
+      throw new Error("Key must only contain letters, numbers, _");
+    }
+    if (isSimpleValue(value)) {
+      keyValuePairs.push([key, value]);
+    } else if (isValueWithOperator(value)) {
+      keyValuePairsWithOperator.push([key, value]);
+    } else if (typeof value === "object" && !("startsWith" in value)) {
+      indexedKeys.push([key, value]);
+    }
+  });
+  filterList = [
+    ...getFiltersFromKeyValuePairs(keyValuePairs),
+    ...getFiltersFromKeyValuePairsWithOperator(keyValuePairsWithOperator)
+  ];
+  indexedKeys.forEach(([key, value]) => {
+    const nestedEntries = Object.entries(value);
+    const nKeyValuePairs = [];
+    const nKeyValuePairsWithOperator = [];
+    nestedEntries.forEach(([nestedKey, nestedValue]) => {
+      if (isStringEmpty(nestedKey)) {
+        throw new Error("Key cannot be empty");
+      }
+      if (isSimpleValue(nestedValue)) {
+        nKeyValuePairs.push([formatFilterKey(key, nestedKey), nestedValue]);
+      } else if (isValueWithOperator(nestedValue)) {
+        nKeyValuePairsWithOperator.push([
+          formatFilterKey(key, nestedKey),
+          nestedValue
+        ]);
+      }
+    });
+    filterList = [
+      ...filterList,
+      ...getFiltersFromKeyValuePairs(nKeyValuePairs),
+      ...getFiltersFromKeyValuePairsWithOperator(nKeyValuePairsWithOperator)
+    ];
+  });
+  return filterList.map(
+    ({ key, operator, value }) => formatFilter(key, operator, formatFilterValue(value))
+  ).join(" AND ");
+}
+var getFiltersFromKeyValuePairs = (keyValuePairs) => {
+  const filters = [];
+  keyValuePairs.forEach(([key, value]) => {
+    filters.push({
+      key,
+      operator: ":",
+      value
+    });
+  });
+  return filters;
+};
+var getFiltersFromKeyValuePairsWithOperator = (keyValuePairsWithOperator) => {
+  const filters = [];
+  keyValuePairsWithOperator.forEach(([key, value]) => {
+    if ("startsWith" in value && typeof value.startsWith === "string") {
+      filters.push({
+        key,
+        operator: "^",
+        value: value.startsWith
+      });
+    }
+  });
+  return filters;
+};
+var isSimpleValue = (value) => {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  return false;
+};
+var isValueWithOperator = (value) => {
+  if (typeof value === "object" && value !== null && "startsWith" in value) {
+    return true;
+  }
+  return false;
+};
+var formatFilter = (key, operator, value) => {
+  return `${key}${operator}${value}`;
+};
+var formatFilterKey = (key, nestedKey) => {
+  if (nestedKey) {
+    return `${key}[${JSON.stringify(nestedKey)}]`;
+  }
+  return key;
+};
+var formatFilterValue = (value) => {
+  if (typeof value === "string") {
+    if (isStringEmpty(value)) {
+      throw new Error("Value cannot be empty");
+    }
+    return JSON.stringify(value);
+  }
+  return value.toString();
+};
+var isStringEmpty = (value) => {
+  return !value || value.toString().trim() === "";
+};
+
 // src/protocol/ClientMsg.ts
 var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
   ClientMsgCode2[ClientMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
@@ -5129,52 +5094,298 @@ function userToTreeNode(key, user) {
     type: "User",
     id: `${user.connectionId}`,
     key,
-    payload: user
+    payload: {
+      connectionId: user.connectionId,
+      id: user.id,
+      info: user.info,
+      presence: user.presence,
+      isReadOnly: !user.canWrite
+    }
   };
 }
 function installBackgroundTabSpy() {
   const doc = typeof document !== "undefined" ? document : void 0;
   const inBackgroundSince = { current: null };
   function onVisibilityChange() {
-    if (_optionalChain([doc, 'optionalAccess', _126 => _126.visibilityState]) === "hidden") {
+    if (_optionalChain([doc, 'optionalAccess', _120 => _120.visibilityState]) === "hidden") {
       inBackgroundSince.current = _nullishCoalesce(inBackgroundSince.current, () => ( Date.now()));
     } else {
       inBackgroundSince.current = null;
     }
   }
-  _optionalChain([doc, 'optionalAccess', _127 => _127.addEventListener, 'call', _128 => _128("visibilitychange", onVisibilityChange)]);
+  _optionalChain([doc, 'optionalAccess', _121 => _121.addEventListener, 'call', _122 => _122("visibilitychange", onVisibilityChange)]);
   const unsub = () => {
-    _optionalChain([doc, 'optionalAccess', _129 => _129.removeEventListener, 'call', _130 => _130("visibilitychange", onVisibilityChange)]);
+    _optionalChain([doc, 'optionalAccess', _123 => _123.removeEventListener, 'call', _124 => _124("visibilitychange", onVisibilityChange)]);
   };
   return [inBackgroundSince, unsub];
 }
-function createRoom(options, config) {
-  const initialPresence = typeof options.initialPresence === "function" ? options.initialPresence(config.roomId) : options.initialPresence;
-  const initialStorage = typeof options.initialStorage === "function" ? options.initialStorage(config.roomId) : options.initialStorage;
-  const [inBackgroundSince, uninstallBgTabSpy] = installBackgroundTabSpy();
-  const delegates = {
-    ...config.delegates,
-    // A connection is allowed to go into "zombie state" only if all of the
-    // following conditions apply:
-    //
-    // - The `backgroundKeepAliveTimeout` client option is configured
-    // - The browser window has been in the background for at least
-    //   `backgroundKeepAliveTimeout` milliseconds
-    // - There are no pending changes
-    //
-    canZombie() {
-      return config.backgroundKeepAliveTimeout !== void 0 && inBackgroundSince.current !== null && Date.now() > inBackgroundSince.current + config.backgroundKeepAliveTimeout && getStorageStatus() !== "synchronizing";
+var CommentsApiError = class extends Error {
+  constructor(message, status, details) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.details = details;
+  }
+};
+function createCommentsApi(roomId, getAuthValue, fetchClientApi) {
+  async function fetchCommentsApi(endpoint, params, options) {
+    const authValue = await getAuthValue();
+    return fetchClientApi(roomId, endpoint, authValue, options, params);
+  }
+  async function fetchJson(endpoint, options, params) {
+    const response = await fetchCommentsApi(endpoint, params, options);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 600) {
+        let error3;
+        try {
+          const errorBody = await response.json();
+          error3 = new CommentsApiError(
+            errorBody.message,
+            response.status,
+            errorBody
+          );
+        } catch (e5) {
+          error3 = new CommentsApiError(response.statusText, response.status);
+        }
+        throw error3;
+      }
     }
-  };
-  const managedSocket = new ManagedSocket(
-    delegates,
-    config.enableDebugLogging
-  );
-  const context = {
-    buffer: {
-      flushTimerID: void 0,
-      lastFlushedAt: 0,
-      presenceUpdates: (
+    let body;
+    try {
+      body = await response.json();
+    } catch (e6) {
+      body = {};
+    }
+    return body;
+  }
+  async function getThreads(options) {
+    let query;
+    if (_optionalChain([options, 'optionalAccess', _125 => _125.query])) {
+      query = objectToQuery(options.query);
+    }
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        since: _optionalChain([options, 'optionalAccess', _126 => _126.since, 'optionalAccess', _127 => _127.toISOString, 'call', _128 => _128()]),
+        query
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: json.data.map((thread) => convertToThreadData(thread)),
+        inboxNotifications: json.inboxNotifications.map(
+          (notification) => convertToInboxNotificationData(notification)
+        ),
+        deletedThreads: json.deletedThreads.map(
+          (info) => convertToThreadDeleteInfo(info)
+        ),
+        deletedInboxNotifications: json.deletedInboxNotifications.map(
+          (info) => convertToInboxNotificationDeleteInfo(info)
+        ),
+        meta: {
+          requestedAt: new Date(json.meta.requestedAt)
+        }
+      };
+    } else if (response.status === 404) {
+      return {
+        threads: [],
+        inboxNotifications: [],
+        deletedThreads: [],
+        deletedInboxNotifications: [],
+        meta: {
+          requestedAt: /* @__PURE__ */ new Date()
+        }
+      };
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  async function getThread({ threadId }) {
+    const response = await fetchCommentsApi(
+      `/thread-with-notification/${threadId}`
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        thread: convertToThreadData(json.thread),
+        inboxNotification: json.inboxNotification ? convertToInboxNotificationData(json.inboxNotification) : void 0
+      };
+    } else if (response.status === 404) {
+      return;
+    } else {
+      throw new Error(`There was an error while getting thread ${threadId}.`);
+    }
+  }
+  async function createThread({
+    metadata,
+    body,
+    commentId,
+    threadId
+  }) {
+    const thread = await fetchJson("/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body
+        },
+        metadata
+      })
+    });
+    return convertToThreadData(thread);
+  }
+  async function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(metadata)
+      }
+    );
+  }
+  async function createComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    const comment = await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: commentId,
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
+  }
+  async function editComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    const comment = await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
+  }
+  async function deleteComment2({
+    threadId,
+    commentId
+  }) {
+    await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async function addReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    const reaction = await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ emoji })
+      }
+    );
+    return convertToCommentUserReaction(reaction);
+  }
+  async function removeReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  return {
+    getThreads,
+    getThread,
+    createThread,
+    editThreadMetadata,
+    createComment,
+    editComment,
+    deleteComment: deleteComment2,
+    addReaction: addReaction2,
+    removeReaction: removeReaction2
+  };
+}
+var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY2 = 50;
+function createRoom(options, config) {
+  const initialPresence = typeof options.initialPresence === "function" ? options.initialPresence(config.roomId) : options.initialPresence;
+  const initialStorage = typeof options.initialStorage === "function" ? options.initialStorage(config.roomId) : options.initialStorage;
+  const [inBackgroundSince, uninstallBgTabSpy] = installBackgroundTabSpy();
+  const delegates = {
+    ...config.delegates,
+    // A connection is allowed to go into "zombie state" only if all of the
+    // following conditions apply:
+    //
+    // - The `backgroundKeepAliveTimeout` client option is configured
+    // - The browser window has been in the background for at least
+    //   `backgroundKeepAliveTimeout` milliseconds
+    // - There are no pending changes
+    //
+    canZombie() {
+      return config.backgroundKeepAliveTimeout !== void 0 && inBackgroundSince.current !== null && Date.now() > inBackgroundSince.current + config.backgroundKeepAliveTimeout && getStorageStatus() !== "synchronizing";
+    }
+  };
+  const managedSocket = new ManagedSocket(
+    delegates,
+    config.enableDebugLogging
+  );
+  const context = {
+    buffer: {
+      flushTimerID: void 0,
+      lastFlushedAt: 0,
+      presenceUpdates: (
         // Queue up the initial presence message as a Full Presence™ update
         {
           type: "full",
@@ -5209,7 +5420,7 @@ function createRoom(options, config) {
   function onStatusDidChange(newStatus) {
     const authValue = managedSocket.authValue;
     if (authValue !== null) {
-      const tokenKey = authValue.type === "secret" ? authValue.token.raw : authValue.publicApiKey;
+      const tokenKey = getAuthBearerHeaderFromAuthValue(authValue);
       if (tokenKey !== lastTokenKey) {
         lastTokenKey = tokenKey;
         if (authValue.type === "secret") {
@@ -5312,7 +5523,9 @@ function createRoom(options, config) {
         }
       }
       if (activeBatch) {
-        activeBatch.ops.push(...ops);
+        for (const op of ops) {
+          activeBatch.ops.push(op);
+        }
         for (const [key, value] of storageUpdates) {
           activeBatch.updates.storageUpdates.set(
             key,
@@ -5333,7 +5546,7 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      const scopes = _optionalChain([context, 'access', _131 => _131.dynamicSessionInfo, 'access', _132 => _132.current, 'optionalAccess', _133 => _133.scopes]);
+      const scopes = _optionalChain([context, 'access', _129 => _129.dynamicSessionInfo, 'access', _130 => _130.current, 'optionalAccess', _131 => _131.scopes]);
       if (scopes === void 0) {
         return;
       }
@@ -5346,8 +5559,6 @@ function createRoom(options, config) {
     }
   };
   const eventHub = {
-    connection: makeEventSource(),
-    // Old/deprecated API
     status: makeEventSource(),
     // New/recommended API
     lostConnection: makeEventSource(),
@@ -5363,29 +5574,91 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
+  async function fetchClientApi(roomId, endpoint, authValue, options2, params) {
+    const url = urljoin(
+      config.baseUrl,
+      `/v2/c/rooms/${encodeURIComponent(roomId)}${endpoint}`,
+      params
+    );
+    const fetcher = _optionalChain([config, 'access', _132 => _132.polyfills, 'optionalAccess', _133 => _133.fetch]) || /* istanbul ignore next */
+    fetch;
+    return await fetcher(url, {
+      ...options2,
+      headers: {
+        ..._optionalChain([options2, 'optionalAccess', _134 => _134.headers]),
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
+      }
+    });
+  }
+  async function streamFetch(authValue, roomId) {
+    return fetchClientApi(roomId, "/storage", authValue, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
   async function httpPostToRoom(endpoint, body) {
     if (!managedSocket.authValue) {
       throw new Error("Not authorized");
     }
-    const authTokenOrPublicApiKey = managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw;
-    const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(config.roomId)}${endpoint}`,
-      config.baseUrl
-    ).toString();
-    const fetcher = _optionalChain([config, 'access', _134 => _134.polyfills, 'optionalAccess', _135 => _135.fetch]) || /* istanbul ignore next */
-    fetch;
-    return fetcher(url, {
+    return fetchClientApi(config.roomId, endpoint, managedSocket.authValue, {
       method: "POST",
       headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authTokenOrPublicApiKey}`
+        "Content-Type": "application/json"
       },
       body: JSON.stringify(body)
     });
   }
+  async function createTextMention(userId, mentionId) {
+    if (!managedSocket.authValue) {
+      throw new Error("Not authorized");
+    }
+    return fetchClientApi(
+      config.roomId,
+      "/text-mentions",
+      managedSocket.authValue,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          userId,
+          mentionId
+        })
+      }
+    );
+  }
+  async function deleteTextMention(mentionId) {
+    if (!managedSocket.authValue) {
+      throw new Error("Not authorized");
+    }
+    return fetchClientApi(
+      config.roomId,
+      `/text-mentions/${mentionId}`,
+      managedSocket.authValue,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async function reportTextEditor(type, rootKey) {
+    const authValue = await delegates.authenticate();
+    return fetchClientApi(config.roomId, "/text-metadata", authValue, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        type,
+        rootKey
+      })
+    });
+  }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
-    const nonce = _optionalChain([context, 'access', _136 => _136.dynamicSessionInfo, 'access', _137 => _137.current, 'optionalAccess', _138 => _138.nonce]);
+    const nonce = _optionalChain([context, 'access', _135 => _135.dynamicSessionInfo, 'access', _136 => _136.current, 'optionalAccess', _137 => _137.nonce]);
     if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
@@ -5419,9 +5692,7 @@ function createRoom(options, config) {
           info: staticSession.userInfo,
           presence: myPresence,
           canWrite,
-          canComment: canComment(dynamicSession.scopes),
-          isReadOnly: !canWrite
-          // Deprecated, kept for backward-compatibility
+          canComment: canComment(dynamicSession.scopes)
         };
       }
     }
@@ -5647,7 +5918,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _139 => _139.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _138 => _138.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -5657,7 +5928,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _140 => _140.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _139 => _139.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -5834,12 +6105,7 @@ function createRoom(options, config) {
             break;
           }
           case 200 /* INITIAL_STORAGE_STATE */: {
-            const unacknowledgedOps = new Map(context.unacknowledgedOps);
-            createOrUpdateRootFromMessage(message, doNotBatchUpdates);
-            applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-            _optionalChain([_resolveStoragePromise, 'optionalCall', _141 => _141()]);
-            notifyStorageStatus();
-            eventHub.storageDidLoad.notify();
+            processInitialStorage(message);
             break;
           }
           case 201 /* UPDATE_STORAGE */: {
@@ -5860,7 +6126,7 @@ function createRoom(options, config) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = _optionalChain([context, 'access', _142 => _142.opStackTraces, 'optionalAccess', _143 => _143.get, 'call', _144 => _144(opId)]);
+                const trace = _optionalChain([context, 'access', _140 => _140.opStackTraces, 'optionalAccess', _141 => _141.get, 'call', _142 => _142(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -5980,14 +6246,35 @@ ${Array.from(traces).join("\n\n")}`
     flushNowOrSoon();
   }
   function dispatchOps(ops) {
-    context.buffer.storageOperations.push(...ops);
+    const { storageOperations } = context.buffer;
+    for (const op of ops) {
+      storageOperations.push(op);
+    }
     flushNowOrSoon();
   }
   let _getStorage$ = null;
   let _resolveStoragePromise = null;
+  function processInitialStorage(message) {
+    const unacknowledgedOps = new Map(context.unacknowledgedOps);
+    createOrUpdateRootFromMessage(message, doNotBatchUpdates);
+    applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _143 => _143()]);
+    notifyStorageStatus();
+    eventHub.storageDidLoad.notify();
+  }
+  async function streamStorage() {
+    if (!managedSocket.authValue) {
+      return;
+    }
+    const result = await streamFetch(managedSocket.authValue, config.roomId);
+    const items = await result.json();
+    processInitialStorage({ type: 200 /* INITIAL_STORAGE_STATE */, items });
+  }
   function refreshStorage(options2) {
     const messages = context.buffer.messages;
-    if (!messages.some((msg) => msg.type === 200 /* FETCH_STORAGE */)) {
+    if (config.unstable_streamData) {
+      void streamStorage();
+    } else if (!messages.some((msg) => msg.type === 200 /* FETCH_STORAGE */)) {
       messages.push({ type: 200 /* FETCH_STORAGE */ });
     }
     if (options2.flush) {
@@ -6165,25 +6452,104 @@ ${Array.from(traces).join("\n\n")}`
     ydoc: eventHub.ydoc.observable,
     comments: eventHub.comments.observable
   };
-  const commentsApi = createCommentsApi(config.roomId, delegates.authenticate, {
-    baseUrl: config.baseUrl
-  });
-  return Object.defineProperty(
-    {
-      /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
-      __internal: {
-        get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _145 => _145.buffer, 'access', _146 => _146.presenceUpdates, 'optionalAccess', _147 => _147.data]), () => ( null)));
-        },
-        // prettier-ignore
-        get undoStack() {
-          return deepClone(context.undoStack);
-        },
-        // prettier-ignore
-        get nodeCount() {
-          return context.nodes.size;
-        },
+  const commentsApi = createCommentsApi(
+    config.roomId,
+    delegates.authenticate,
+    fetchClientApi
+  );
+  async function fetchNotificationsJson(endpoint, options2) {
+    const authValue = await delegates.authenticate();
+    const response = await fetchClientApi(
+      config.roomId,
+      endpoint,
+      authValue,
+      options2
+    );
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 600) {
+        let error3;
+        try {
+          const errorBody = await response.json();
+          error3 = new NotificationsApiError(
+            errorBody.message,
+            response.status,
+            errorBody
+          );
+        } catch (e7) {
+          error3 = new NotificationsApiError(
+            response.statusText,
+            response.status
+          );
+        }
+        throw error3;
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch (e8) {
+      body = {};
+    }
+    return body;
+  }
+  function getRoomNotificationSettings() {
+    return fetchNotificationsJson(
+      "/notification-settings"
+    );
+  }
+  function updateRoomNotificationSettings(settings) {
+    return fetchNotificationsJson(
+      "/notification-settings",
+      {
+        method: "POST",
+        body: JSON.stringify(settings),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+  }
+  async function markInboxNotificationsAsRead(inboxNotificationIds) {
+    await fetchNotificationsJson("/inbox-notifications/read", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ inboxNotificationIds })
+    });
+  }
+  const batchedMarkInboxNotificationsAsRead = new Batch(
+    async (batchedInboxNotificationIds) => {
+      const inboxNotificationIds = batchedInboxNotificationIds.flat();
+      await markInboxNotificationsAsRead(inboxNotificationIds);
+      return inboxNotificationIds;
+    },
+    { delay: MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY2 }
+  );
+  async function markInboxNotificationAsRead(inboxNotificationId) {
+    await batchedMarkInboxNotificationsAsRead.get(inboxNotificationId);
+  }
+  return Object.defineProperty(
+    {
+      [kInternal]: {
+        get presenceBuffer() {
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _144 => _144.buffer, 'access', _145 => _145.presenceUpdates, 'optionalAccess', _146 => _146.data]), () => ( null)));
+        },
         // prettier-ignore
+        get undoStack() {
+          return deepClone(context.undoStack);
+        },
+        // prettier-ignore
+        get nodeCount() {
+          return context.nodes.size;
+        },
+        // prettier-ignore
+        // send metadata when using a text editor
+        reportTextEditor,
+        // create a text mention when using a text editor
+        createTextMention,
+        // delete a text mention when using a text editor
+        deleteTextMention,
         // Support for the Liveblocks browser extension
         getSelf_forDevTools: () => selfAsTreeNode.current,
         getOthers_forDevTools: () => others_forDevTools.current,
@@ -6192,6 +6558,14 @@ ${Array.from(traces).join("\n\n")}`
           // These exist only for our E2E testing app
           explicitClose: (event) => managedSocket._privateSendMachineEvent({ type: "EXPLICIT_SOCKET_CLOSE", event }),
           rawSend: (data) => managedSocket.send(data)
+        },
+        comments: {
+          ...commentsApi
+        },
+        notifications: {
+          getRoomNotificationSettings,
+          updateRoomNotificationSettings,
+          markInboxNotificationAsRead
         }
       },
       id: config.roomId,
@@ -6225,16 +6599,14 @@ ${Array.from(traces).join("\n\n")}`
       events,
       // Core
       getStatus: () => managedSocket.getStatus(),
-      getConnectionState: () => managedSocket.getLegacyStatus(),
       getSelf: () => self.current,
       // Presence
       getPresence: () => context.myPresence.current,
-      getOthers: () => context.others.current,
-      ...commentsApi
+      getOthers: () => context.others.current
     },
-    // Explictly make the __internal field non-enumerable, to avoid aggressive
+    // Explictly make the internal field non-enumerable, to avoid aggressive
     // freezing when used with Immer
-    "__internal",
+    kInternal,
     { enumerable: false }
   );
 }
@@ -6280,12 +6652,6 @@ function makeClassicSubscribeFn(events) {
         }
         case "error":
           return events.error.subscribe(callback);
-        case "connection": {
-          const cb = callback;
-          return events.status.subscribe(
-            (status) => cb(newToLegacyStatus(status))
-          );
-        }
         case "status":
           return events.status.subscribe(callback);
         case "lost-connection":
@@ -6315,7 +6681,7 @@ function makeClassicSubscribeFn(events) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _148 => _148.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _147 => _147.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -6334,7 +6700,7 @@ function isRoomEventName(value) {
 }
 function makeAuthDelegateForRoom(roomId, authManager) {
   return async () => {
-    return authManager.getAuthValue("room:read", roomId);
+    return authManager.getAuthValue({ requestedScope: "room:read", roomId });
   };
 }
 function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
@@ -6361,6 +6727,470 @@ function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
   };
 }
 
+// src/store.ts
+function createClientStore() {
+  const store = createStore({
+    threads: {},
+    queries: {},
+    optimisticUpdates: [],
+    inboxNotifications: {},
+    notificationSettings: {}
+  });
+  const optimisticUpdatesEventSource = makeEventSource();
+  return {
+    ...store,
+    deleteThread(threadId) {
+      store.set((state) => {
+        return {
+          ...state,
+          threads: deleteKeyImmutable(state.threads, threadId),
+          inboxNotifications: Object.fromEntries(
+            Object.entries(state.inboxNotifications).filter(
+              ([_id, notification]) => notification.kind === "thread" && notification.threadId === threadId
+            )
+          )
+        };
+      });
+    },
+    updateThreadAndNotification(thread, inboxNotification) {
+      store.set((state) => {
+        const existingThread = state.threads[thread.id];
+        return {
+          ...state,
+          threads: existingThread === void 0 || compareThreads(thread, existingThread) === 1 ? { ...state.threads, [thread.id]: thread } : state.threads,
+          inboxNotifications: inboxNotification === void 0 ? state.inboxNotifications : {
+            ...state.inboxNotifications,
+            [inboxNotification.id]: inboxNotification
+          }
+        };
+      });
+    },
+    updateThreadsAndNotifications(threads, inboxNotifications, deletedThreads, deletedInboxNotifications, queryKey) {
+      store.set((state) => ({
+        ...state,
+        threads: applyThreadUpdates(state.threads, {
+          newThreads: threads,
+          deletedThreads
+        }),
+        inboxNotifications: applyNotificationsUpdates(
+          state.inboxNotifications,
+          {
+            newInboxNotifications: inboxNotifications,
+            deletedNotifications: deletedInboxNotifications
+          }
+        ),
+        queries: queryKey !== void 0 ? {
+          ...state.queries,
+          [queryKey]: {
+            isLoading: false
+          }
+        } : state.queries
+      }));
+    },
+    updateRoomInboxNotificationSettings(roomId, settings, queryKey) {
+      store.set((state) => ({
+        ...state,
+        notificationSettings: {
+          ...state.notificationSettings,
+          [roomId]: settings
+        },
+        queries: {
+          ...state.queries,
+          [queryKey]: {
+            isLoading: false
+          }
+        }
+      }));
+    },
+    pushOptimisticUpdate(optimisticUpdate) {
+      optimisticUpdatesEventSource.notify(optimisticUpdate);
+      store.set((state) => ({
+        ...state,
+        optimisticUpdates: [...state.optimisticUpdates, optimisticUpdate]
+      }));
+    },
+    setQueryState(queryKey, queryState) {
+      store.set((state) => ({
+        ...state,
+        queries: {
+          ...state.queries,
+          [queryKey]: queryState
+        }
+      }));
+    },
+    optimisticUpdatesEventSource
+  };
+}
+function deleteKeyImmutable(record, key) {
+  if (Object.prototype.hasOwnProperty.call(record, key)) {
+    const { [key]: _toDelete, ...rest } = record;
+    return rest;
+  }
+  return record;
+}
+function compareThreads(thread1, thread2) {
+  if (thread1.updatedAt && thread2.updatedAt) {
+    return thread1.updatedAt > thread2.updatedAt ? 1 : thread1.updatedAt < thread2.updatedAt ? -1 : 0;
+  } else if (thread1.updatedAt || thread2.updatedAt) {
+    return thread1.updatedAt ? 1 : -1;
+  }
+  if (thread1.createdAt > thread2.createdAt) {
+    return 1;
+  } else if (thread1.createdAt < thread2.createdAt) {
+    return -1;
+  }
+  return 0;
+}
+function applyOptimisticUpdates(state) {
+  const result = {
+    threads: {
+      ...state.threads
+    },
+    inboxNotifications: {
+      ...state.inboxNotifications
+    },
+    notificationSettings: {
+      ...state.notificationSettings
+    }
+  };
+  for (const optimisticUpdate of state.optimisticUpdates) {
+    switch (optimisticUpdate.type) {
+      case "create-thread": {
+        result.threads[optimisticUpdate.thread.id] = optimisticUpdate.thread;
+        break;
+      }
+      case "edit-thread-metadata": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        if (thread.deletedAt !== void 0) {
+          break;
+        }
+        if (thread.updatedAt !== void 0 && thread.updatedAt > optimisticUpdate.updatedAt) {
+          break;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          updatedAt: optimisticUpdate.updatedAt,
+          metadata: {
+            ...thread.metadata,
+            ...optimisticUpdate.metadata
+          }
+        };
+        break;
+      }
+      case "create-comment": {
+        const thread = result.threads[optimisticUpdate.comment.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = upsertComment(
+          thread,
+          optimisticUpdate.comment
+        );
+        const inboxNotification = Object.values(result.inboxNotifications).find(
+          (notification) => notification.kind === "thread" && notification.threadId === thread.id
+        );
+        if (inboxNotification === void 0) {
+          break;
+        }
+        result.inboxNotifications[inboxNotification.id] = {
+          ...inboxNotification,
+          notifiedAt: optimisticUpdate.comment.createdAt,
+          readAt: optimisticUpdate.comment.createdAt
+        };
+        break;
+      }
+      case "edit-comment": {
+        const thread = result.threads[optimisticUpdate.comment.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = upsertComment(
+          thread,
+          optimisticUpdate.comment
+        );
+        break;
+      }
+      case "delete-comment": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = deleteComment(
+          thread,
+          optimisticUpdate.commentId,
+          optimisticUpdate.deletedAt
+        );
+        break;
+      }
+      case "add-reaction": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = addReaction(
+          thread,
+          optimisticUpdate.commentId,
+          optimisticUpdate.reaction
+        );
+        break;
+      }
+      case "remove-reaction": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = removeReaction(
+          thread,
+          optimisticUpdate.commentId,
+          optimisticUpdate.emoji,
+          optimisticUpdate.userId,
+          optimisticUpdate.removedAt
+        );
+        break;
+      }
+      case "mark-inbox-notification-as-read": {
+        result.inboxNotifications[optimisticUpdate.inboxNotificationId] = {
+          ...state.inboxNotifications[optimisticUpdate.inboxNotificationId],
+          readAt: optimisticUpdate.readAt
+        };
+        break;
+      }
+      case "mark-inbox-notifications-as-read": {
+        for (const id in result.inboxNotifications) {
+          result.inboxNotifications[id] = {
+            ...result.inboxNotifications[id],
+            readAt: optimisticUpdate.readAt
+          };
+        }
+        break;
+      }
+      case "update-notification-settings": {
+        result.notificationSettings[optimisticUpdate.roomId] = {
+          ...result.notificationSettings[optimisticUpdate.roomId],
+          ...optimisticUpdate.settings
+        };
+      }
+    }
+  }
+  return result;
+}
+function applyThreadUpdates(existingThreads, updates) {
+  const updatedThreads = { ...existingThreads };
+  updates.newThreads.forEach((thread) => {
+    const existingThread = updatedThreads[thread.id];
+    if (existingThread) {
+      const result = compareThreads(existingThread, thread);
+      if (result === 1) return;
+    }
+    updatedThreads[thread.id] = thread;
+  });
+  updates.deletedThreads.forEach(({ id, deletedAt }) => {
+    const existingThread = updatedThreads[id];
+    if (existingThread === void 0) return;
+    existingThread.deletedAt = deletedAt;
+    existingThread.updatedAt = deletedAt;
+    existingThread.comments = [];
+  });
+  return updatedThreads;
+}
+function applyNotificationsUpdates(existingInboxNotifications, updates) {
+  const updatedInboxNotifications = { ...existingInboxNotifications };
+  updates.newInboxNotifications.forEach((notification) => {
+    const existingNotification = updatedInboxNotifications[notification.id];
+    if (existingNotification) {
+      const result = compareInboxNotifications(
+        existingNotification,
+        notification
+      );
+      if (result === 1) return;
+    }
+    updatedInboxNotifications[notification.id] = notification;
+  });
+  updates.deletedNotifications.forEach(
+    ({ id }) => delete updatedInboxNotifications[id]
+  );
+  return updatedInboxNotifications;
+}
+function compareInboxNotifications(inboxNotificationA, inboxNotificationB) {
+  if (inboxNotificationA.notifiedAt > inboxNotificationB.notifiedAt) {
+    return 1;
+  } else if (inboxNotificationA.notifiedAt < inboxNotificationB.notifiedAt) {
+    return -1;
+  }
+  if (inboxNotificationA.readAt && inboxNotificationB.readAt) {
+    return inboxNotificationA.readAt > inboxNotificationB.readAt ? 1 : inboxNotificationA.readAt < inboxNotificationB.readAt ? -1 : 0;
+  } else if (inboxNotificationA.readAt || inboxNotificationB.readAt) {
+    return inboxNotificationA.readAt ? 1 : -1;
+  }
+  return 0;
+}
+function upsertComment(thread, comment) {
+  if (thread.deletedAt !== void 0) {
+    return thread;
+  }
+  if (comment.threadId !== thread.id) {
+    warn(
+      `Comment ${comment.id} does not belong to thread ${thread.id}`
+    );
+    return thread;
+  }
+  const existingComment = thread.comments.find(
+    (existingComment2) => existingComment2.id === comment.id
+  );
+  if (existingComment === void 0) {
+    const updatedAt = new Date(
+      Math.max(_optionalChain([thread, 'access', _148 => _148.updatedAt, 'optionalAccess', _149 => _149.getTime, 'call', _150 => _150()]) || 0, comment.createdAt.getTime())
+    );
+    const updatedThread = {
+      ...thread,
+      updatedAt,
+      comments: [...thread.comments, comment]
+    };
+    return updatedThread;
+  }
+  if (existingComment.deletedAt !== void 0) {
+    return thread;
+  }
+  if (existingComment.editedAt === void 0 || comment.editedAt === void 0 || existingComment.editedAt <= comment.editedAt) {
+    const updatedComments = thread.comments.map(
+      (existingComment2) => existingComment2.id === comment.id ? comment : existingComment2
+    );
+    const updatedThread = {
+      ...thread,
+      updatedAt: new Date(
+        Math.max(
+          _optionalChain([thread, 'access', _151 => _151.updatedAt, 'optionalAccess', _152 => _152.getTime, 'call', _153 => _153()]) || 0,
+          _optionalChain([comment, 'access', _154 => _154.editedAt, 'optionalAccess', _155 => _155.getTime, 'call', _156 => _156()]) || comment.createdAt.getTime()
+        )
+      ),
+      comments: updatedComments
+    };
+    return updatedThread;
+  }
+  return thread;
+}
+function deleteComment(thread, commentId, deletedAt) {
+  if (thread.deletedAt !== void 0) {
+    return thread;
+  }
+  const existingComment = thread.comments.find(
+    (comment) => comment.id === commentId
+  );
+  if (existingComment === void 0) {
+    return thread;
+  }
+  if (existingComment.deletedAt !== void 0) {
+    return thread;
+  }
+  const updatedComments = thread.comments.map(
+    (comment) => comment.id === commentId ? {
+      ...comment,
+      deletedAt,
+      body: void 0
+    } : comment
+  );
+  if (!updatedComments.some((comment) => comment.deletedAt === void 0)) {
+    return {
+      ...thread,
+      deletedAt,
+      updatedAt: deletedAt,
+      comments: []
+    };
+  }
+  return {
+    ...thread,
+    updatedAt: deletedAt,
+    comments: updatedComments
+  };
+}
+function addReaction(thread, commentId, reaction) {
+  if (thread.deletedAt !== void 0) {
+    return thread;
+  }
+  const existingComment = thread.comments.find(
+    (comment) => comment.id === commentId
+  );
+  if (existingComment === void 0) {
+    return thread;
+  }
+  if (existingComment.deletedAt !== void 0) {
+    return thread;
+  }
+  const updatedComments = thread.comments.map(
+    (comment) => comment.id === commentId ? {
+      ...comment,
+      reactions: upsertReaction(comment.reactions, reaction)
+    } : comment
+  );
+  return {
+    ...thread,
+    updatedAt: new Date(
+      Math.max(reaction.createdAt.getTime(), _optionalChain([thread, 'access', _157 => _157.updatedAt, 'optionalAccess', _158 => _158.getTime, 'call', _159 => _159()]) || 0)
+    ),
+    comments: updatedComments
+  };
+}
+function removeReaction(thread, commentId, emoji, userId, removedAt) {
+  if (thread.deletedAt !== void 0) {
+    return thread;
+  }
+  const existingComment = thread.comments.find(
+    (comment) => comment.id === commentId
+  );
+  if (existingComment === void 0) {
+    return thread;
+  }
+  if (existingComment.deletedAt !== void 0) {
+    return thread;
+  }
+  const updatedComments = thread.comments.map(
+    (comment) => comment.id === commentId ? {
+      ...comment,
+      reactions: comment.reactions.map(
+        (reaction) => reaction.emoji === emoji ? {
+          ...reaction,
+          users: reaction.users.filter((user) => user.id !== userId)
+        } : reaction
+      ).filter((reaction) => reaction.users.length > 0)
+      // Remove reactions with no users left
+    } : comment
+  );
+  return {
+    ...thread,
+    updatedAt: new Date(
+      Math.max(removedAt.getTime(), _optionalChain([thread, 'access', _160 => _160.updatedAt, 'optionalAccess', _161 => _161.getTime, 'call', _162 => _162()]) || 0)
+    ),
+    comments: updatedComments
+  };
+}
+function upsertReaction(reactions, reaction) {
+  const existingReaction = reactions.find(
+    (existingReaction2) => existingReaction2.emoji === reaction.emoji
+  );
+  if (existingReaction === void 0) {
+    return [
+      ...reactions,
+      {
+        emoji: reaction.emoji,
+        createdAt: reaction.createdAt,
+        users: [{ id: reaction.userId }]
+      }
+    ];
+  }
+  if (existingReaction.users.some((user) => user.id === reaction.userId) === false) {
+    return reactions.map(
+      (existingReaction2) => existingReaction2.emoji === reaction.emoji ? {
+        ...existingReaction2,
+        users: [...existingReaction2.users, { id: reaction.userId }]
+      } : existingReaction2
+    );
+  }
+  return reactions;
+}
+
 // src/client.ts
 var MIN_THROTTLE = 16;
 var MAX_THROTTLE = 1e3;
@@ -6370,16 +7200,22 @@ var MIN_LOST_CONNECTION_TIMEOUT = 200;
 var RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT = 1e3;
 var MAX_LOST_CONNECTION_TIMEOUT = 3e4;
 var DEFAULT_LOST_CONNECTION_TIMEOUT = 5e3;
-function getBaseUrlFromClientOptions(clientOptions) {
-  if ("liveblocksServer" in clientOptions) {
-    throw new Error("Client option no longer supported");
-  }
-  if (typeof clientOptions.baseUrl === "string" && clientOptions.baseUrl.startsWith("http")) {
-    return clientOptions.baseUrl;
+var RESOLVE_USERS_BATCH_DELAY = 50;
+var RESOLVE_ROOMS_INFO_BATCH_DELAY = 50;
+function getBaseUrl(baseUrl) {
+  if (typeof baseUrl === "string" && baseUrl.startsWith("http")) {
+    return baseUrl;
   } else {
     return DEFAULT_BASE_URL;
   }
 }
+function getAuthBearerHeaderFromAuthValue(authValue) {
+  if (authValue.type === "public") {
+    return authValue.publicApiKey;
+  } else {
+    return authValue.token.raw;
+  }
+}
 function createClient(options) {
   const clientOptions = options;
   const throttleDelay = getThrottle(_nullishCoalesce(clientOptions.throttle, () => ( DEFAULT_THROTTLE)));
@@ -6389,6 +7225,7 @@ function createClient(options) {
   const backgroundKeepAliveTimeout = getBackgroundKeepAliveTimeout(
     clientOptions.backgroundKeepAliveTimeout
   );
+  const baseUrl = getBaseUrl(clientOptions.baseUrl);
   const authManager = createAuthManager(options);
   const roomsById = /* @__PURE__ */ new Map();
   function teardownRoom(room) {
@@ -6396,22 +7233,22 @@ function createClient(options) {
     roomsById.delete(room.id);
     room.destroy();
   }
-  function leaseRoom(info) {
+  function leaseRoom(details) {
     const leave = () => {
       const self = leave;
-      if (!info.unsubs.delete(self)) {
+      if (!details.unsubs.delete(self)) {
         warn(
           "This leave function was already called. Calling it more than once has no effect."
         );
       } else {
-        if (info.unsubs.size === 0) {
-          teardownRoom(info.room);
+        if (details.unsubs.size === 0) {
+          teardownRoom(details.room);
         }
       }
     };
-    info.unsubs.add(leave);
+    details.unsubs.add(leave);
     return {
-      room: info.room,
+      room: details.room,
       leave
     };
   }
@@ -6424,7 +7261,6 @@ function createClient(options) {
       options2.initialPresence === null || options2.initialPresence === void 0,
       "Please provide an initial presence value for the current user when entering the room."
     );
-    const baseUrl = getBaseUrlFromClientOptions(clientOptions);
     const newRoom = createRoom(
       {
         initialPresence: _nullishCoalesce(options2.initialPresence, () => ( {})),
@@ -6440,27 +7276,28 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             baseUrl,
-            _optionalChain([clientOptions, 'access', _149 => _149.polyfills, 'optionalAccess', _150 => _150.WebSocket])
+            _optionalChain([clientOptions, 'access', _163 => _163.polyfills, 'optionalAccess', _164 => _164.WebSocket])
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         })),
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _151 => _151.unstable_batchedUpdates]),
+        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _165 => _165.unstable_batchedUpdates]),
         baseUrl,
-        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP
+        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP,
+        unstable_streamData: !!clientOptions.unstable_streamData
       }
     );
-    const newRoomInfo = {
+    const newRoomDetails = {
       room: newRoom,
       unsubs: /* @__PURE__ */ new Set()
     };
-    roomsById.set(roomId, newRoomInfo);
+    roomsById.set(roomId, newRoomDetails);
     setupDevTools(() => Array.from(roomsById.keys()));
     linkDevTools(roomId, newRoom);
-    const shouldConnect = _nullishCoalesce(_nullishCoalesce(options2.autoConnect, () => ( options2.shouldInitiallyConnect)), () => ( true));
+    const shouldConnect = _nullishCoalesce(options2.autoConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _152 => _152.polyfills, 'optionalAccess', _153 => _153.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _166 => _166.polyfills, 'optionalAccess', _167 => _167.atob]) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
@@ -6469,68 +7306,449 @@ function createClient(options) {
       }
       newRoom.connect();
     }
-    return leaseRoom(newRoomInfo);
-  }
-  function enter(roomId, options2) {
-    const { room, leave: _ } = enterRoom(roomId, options2);
-    return room;
+    return leaseRoom(newRoomDetails);
   }
   function getRoom(roomId) {
-    const room = _optionalChain([roomsById, 'access', _154 => _154.get, 'call', _155 => _155(roomId), 'optionalAccess', _156 => _156.room]);
+    const room = _optionalChain([roomsById, 'access', _168 => _168.get, 'call', _169 => _169(roomId), 'optionalAccess', _170 => _170.room]);
     return room ? room : null;
   }
-  function forceLeave(roomId) {
-    const unsubs = _nullishCoalesce(_optionalChain([roomsById, 'access', _157 => _157.get, 'call', _158 => _158(roomId), 'optionalAccess', _159 => _159.unsubs]), () => ( /* @__PURE__ */ new Set()));
-    for (const unsub of unsubs) {
-      unsub();
+  function logout() {
+    authManager.reset();
+    for (const { room } of roomsById.values()) {
+      if (!isIdle(room.getStatus())) {
+        room.reconnect();
+      }
+    }
+  }
+  const currentUserIdStore = createStore(null);
+  const {
+    getInboxNotifications,
+    getUnreadInboxNotificationsCount,
+    markAllInboxNotificationsAsRead,
+    markInboxNotificationAsRead
+  } = createNotificationsApi({
+    baseUrl,
+    fetcher: _optionalChain([clientOptions, 'access', _171 => _171.polyfills, 'optionalAccess', _172 => _172.fetch]) || /* istanbul ignore next */
+    fetch,
+    authManager,
+    currentUserIdStore
+  });
+  const cacheStore = createClientStore();
+  const resolveUsers = clientOptions.resolveUsers;
+  const warnIfNoResolveUsers = createDevelopmentWarning(
+    () => !resolveUsers,
+    "Set the resolveUsers option in createClient to specify user info."
+  );
+  const usersStore = createBatchStore(
+    async (batchedUserIds) => {
+      const userIds = batchedUserIds.flat();
+      const users = await _optionalChain([resolveUsers, 'optionalCall', _173 => _173({ userIds })]);
+      warnIfNoResolveUsers();
+      return _nullishCoalesce(users, () => ( userIds.map(() => void 0)));
+    },
+    { delay: RESOLVE_USERS_BATCH_DELAY }
+  );
+  const resolveRoomsInfo = clientOptions.resolveRoomsInfo;
+  const warnIfNoResolveRoomsInfo = createDevelopmentWarning(
+    () => !resolveRoomsInfo,
+    "Set the resolveRoomsInfo option in createClient to specify room info."
+  );
+  const roomsInfoStore = createBatchStore(
+    async (batchedRoomIds) => {
+      const roomIds = batchedRoomIds.flat();
+      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _174 => _174({ roomIds })]);
+      warnIfNoResolveRoomsInfo();
+      return _nullishCoalesce(roomsInfo, () => ( roomIds.map(() => void 0)));
+    },
+    { delay: RESOLVE_ROOMS_INFO_BATCH_DELAY }
+  );
+  return Object.defineProperty(
+    {
+      enterRoom,
+      getRoom,
+      logout,
+      // Internal
+      [kInternal]: {
+        notifications: {
+          getInboxNotifications,
+          getUnreadInboxNotificationsCount,
+          markAllInboxNotificationsAsRead,
+          markInboxNotificationAsRead
+        },
+        currentUserIdStore,
+        resolveMentionSuggestions: clientOptions.resolveMentionSuggestions,
+        cacheStore,
+        usersStore,
+        roomsInfoStore,
+        getRoomIds() {
+          return Array.from(roomsById.keys());
+        }
+      }
+    },
+    kInternal,
+    {
+      enumerable: false
+    }
+  );
+}
+var NotificationsApiError = class extends Error {
+  constructor(message, status, details) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.details = details;
+  }
+};
+function checkBounds(option, value, min, max, recommendedMin) {
+  if (typeof value !== "number" || value < min || max !== void 0 && value > max) {
+    throw new Error(
+      max !== void 0 ? `${option} should be between ${_nullishCoalesce(recommendedMin, () => ( min))} and ${max}.` : `${option} should be at least ${_nullishCoalesce(recommendedMin, () => ( min))}.`
+    );
+  }
+  return value;
+}
+function getBackgroundKeepAliveTimeout(value) {
+  if (value === void 0) return void 0;
+  return checkBounds(
+    "backgroundKeepAliveTimeout",
+    value,
+    MIN_BACKGROUND_KEEP_ALIVE_TIMEOUT
+  );
+}
+function getThrottle(value) {
+  return checkBounds("throttle", value, MIN_THROTTLE, MAX_THROTTLE);
+}
+function getLostConnectionTimeout(value) {
+  return checkBounds(
+    "lostConnectionTimeout",
+    value,
+    MIN_LOST_CONNECTION_TIMEOUT,
+    MAX_LOST_CONNECTION_TIMEOUT,
+    RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT
+  );
+}
+function createDevelopmentWarning(condition, ...args) {
+  let hasWarned = false;
+  if (process.env.NODE_ENV !== "production") {
+    return () => {
+      if (!hasWarned && (typeof condition === "function" ? condition() : condition)) {
+        warn(...args);
+        hasWarned = true;
+      }
+    };
+  } else {
+    return () => {
+    };
+  }
+}
+
+// src/comments/comment-body.ts
+function isCommentBodyParagraph(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyText(element) {
+  return "text" in element && typeof element.text === "string";
+}
+function isCommentBodyMention(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyLink(element) {
+  return "type" in element && element.type === "link";
+}
+var commentBodyElementsGuards = {
+  paragraph: isCommentBodyParagraph,
+  text: isCommentBodyText,
+  link: isCommentBodyLink,
+  mention: isCommentBodyMention
+};
+var commentBodyElementsTypes = {
+  paragraph: "block",
+  text: "inline",
+  link: "inline",
+  mention: "inline"
+};
+function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _175 => _175.content])) {
+    return;
+  }
+  const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
+  const type = element ? commentBodyElementsTypes[element] : "all";
+  const guard = element ? commentBodyElementsGuards[element] : () => true;
+  const visitor = typeof elementOrVisitor === "function" ? elementOrVisitor : possiblyVisitor;
+  for (const block of body.content) {
+    if (type === "all" || type === "block") {
+      if (guard(block)) {
+        _optionalChain([visitor, 'optionalCall', _176 => _176(block)]);
+      }
+    }
+    if (type === "all" || type === "inline") {
+      for (const inline of block.children) {
+        if (guard(inline)) {
+          _optionalChain([visitor, 'optionalCall', _177 => _177(inline)]);
+        }
+      }
+    }
+  }
+}
+function getMentionedIdsFromCommentBody(body) {
+  const mentionedIds = /* @__PURE__ */ new Set();
+  traverseCommentBody(
+    body,
+    "mention",
+    (mention) => mentionedIds.add(mention.id)
+  );
+  return Array.from(mentionedIds);
+}
+async function resolveUsersInCommentBody(body, resolveUsers) {
+  const resolvedUsers = /* @__PURE__ */ new Map();
+  if (!resolveUsers) {
+    return resolvedUsers;
+  }
+  const userIds = getMentionedIdsFromCommentBody(body);
+  const users = await resolveUsers({
+    userIds
+  });
+  for (const [index, userId] of userIds.entries()) {
+    const user = _optionalChain([users, 'optionalAccess', _178 => _178[index]]);
+    if (user) {
+      resolvedUsers.set(userId, user);
+    }
+  }
+  return resolvedUsers;
+}
+var htmlEscapables = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var htmlEscapablesRegex = new RegExp(
+  Object.keys(htmlEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function htmlSafe(value) {
+  return new HtmlSafeString([String(value)], []);
+}
+function joinHtml(strings) {
+  if (strings.length <= 0) {
+    return new HtmlSafeString([""], []);
+  }
+  return new HtmlSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeHtml(value) {
+  if (value instanceof HtmlSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinHtml(value).toString();
+  }
+  return String(value).replace(
+    htmlEscapablesRegex,
+    (character) => htmlEscapables[character]
+  );
+}
+var HtmlSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeHtml(nn(this._values[i - 1])) + str;
+    });
+  }
+};
+function html(strings, ...values) {
+  return new HtmlSafeString(strings, values);
+}
+var markdownEscapables = {
+  _: "\\_",
+  "*": "\\*",
+  "#": "\\#",
+  "`": "\\`",
+  "~": "\\~",
+  "!": "\\!",
+  "|": "\\|",
+  "(": "\\(",
+  ")": "\\)",
+  "{": "\\{",
+  "}": "\\}",
+  "[": "\\[",
+  "]": "\\]"
+};
+var markdownEscapablesRegex = new RegExp(
+  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function joinMarkdown(strings) {
+  if (strings.length <= 0) {
+    return new MarkdownSafeString([""], []);
+  }
+  return new MarkdownSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeMarkdown(value) {
+  if (value instanceof MarkdownSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinMarkdown(value).toString();
+  }
+  return String(value).replace(
+    markdownEscapablesRegex,
+    (character) => markdownEscapables[character]
+  );
+}
+var MarkdownSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeMarkdown(nn(this._values[i - 1])) + str;
+    });
+  }
+};
+function markdown(strings, ...values) {
+  return new MarkdownSafeString(strings, values);
+}
+function toAbsoluteUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  } else if (url.startsWith("www.")) {
+    return "https://" + url;
+  }
+  return;
+}
+var stringifyCommentBodyPlainElements = {
+  paragraph: ({ children }) => children,
+  text: ({ element }) => element.text,
+  link: ({ element }) => element.url,
+  mention: ({ element, user }) => {
+    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _179 => _179.name]), () => ( element.id))}`;
+  }
+};
+var stringifyCommentBodyHtmlElements = {
+  paragraph: ({ children }) => {
+    return children ? html`<p>${htmlSafe(children)}</p>` : children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
+    }
+    if (element.bold) {
+      children = html`<strong>${children}</strong>`;
+    }
+    if (element.italic) {
+      children = html`<em>${children}</em>`;
+    }
+    if (element.strikethrough) {
+      children = html`<s>${children}</s>`;
+    }
+    if (element.code) {
+      children = html`<code>${children}</code>`;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.url}</a>`;
+  },
+  mention: ({ element, user }) => {
+    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _180 => _180.name]), () => ( element.id))}</span>`;
+  }
+};
+var stringifyCommentBodyMarkdownElements = {
+  paragraph: ({ children }) => {
+    return children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
     }
-  }
-  function logout() {
-    authManager.reset();
-    for (const { room } of roomsById.values()) {
-      if (!isIdle(room.getStatus())) {
-        room.reconnect();
-      }
+    if (element.bold) {
+      children = markdown`**${children}**`;
+    }
+    if (element.italic) {
+      children = markdown`_${children}_`;
+    }
+    if (element.strikethrough) {
+      children = markdown`~~${children}~~`;
+    }
+    if (element.code) {
+      children = markdown`\`${children}\``;
     }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return markdown`[${element.url}](${href})`;
+  },
+  mention: ({ element, user }) => {
+    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _181 => _181.name]), () => ( element.id))}`;
   }
-  return {
-    logout,
-    // Old, deprecated APIs
-    enter,
-    getRoom,
-    leave: forceLeave,
-    // New, preferred API
-    enterRoom
+};
+async function stringifyCommentBody(body, options) {
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _182 => _182.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _183 => _183.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const elements = {
+    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
+    ..._optionalChain([options, 'optionalAccess', _184 => _184.elements])
   };
-}
-function checkBounds(option, value, min, max, recommendedMin) {
-  if (typeof value !== "number" || value < min || max !== void 0 && value > max) {
-    throw new Error(
-      max !== void 0 ? `${option} should be between ${_nullishCoalesce(recommendedMin, () => ( min))} and ${max}.` : `${option} should be at least ${_nullishCoalesce(recommendedMin, () => ( min))}.`
-    );
-  }
-  return value;
-}
-function getBackgroundKeepAliveTimeout(value) {
-  if (value === void 0)
-    return void 0;
-  return checkBounds(
-    "backgroundKeepAliveTimeout",
-    value,
-    MIN_BACKGROUND_KEEP_ALIVE_TIMEOUT
-  );
-}
-function getThrottle(value) {
-  return checkBounds("throttle", value, MIN_THROTTLE, MAX_THROTTLE);
-}
-function getLostConnectionTimeout(value) {
-  return checkBounds(
-    "lostConnectionTimeout",
-    value,
-    MIN_LOST_CONNECTION_TIMEOUT,
-    MAX_LOST_CONNECTION_TIMEOUT,
-    RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT
+  const resolvedUsers = await resolveUsersInCommentBody(
+    body,
+    _optionalChain([options, 'optionalAccess', _185 => _185.resolveUsers])
   );
+  const blocks = body.content.flatMap((block, blockIndex) => {
+    switch (block.type) {
+      case "paragraph": {
+        const inlines = block.children.flatMap((inline, inlineIndex) => {
+          if (isCommentBodyMention(inline)) {
+            return inline.id ? [
+              elements.mention(
+                {
+                  element: inline,
+                  user: resolvedUsers.get(inline.id)
+                },
+                inlineIndex
+              )
+            ] : [];
+          }
+          if (isCommentBodyLink(inline)) {
+            return [
+              elements.link(
+                {
+                  element: inline,
+                  href: _nullishCoalesce(toAbsoluteUrl(inline.url), () => ( inline.url))
+                },
+                inlineIndex
+              )
+            ];
+          }
+          if (isCommentBodyText(inline)) {
+            return [elements.text({ element: inline }, inlineIndex)];
+          }
+          return [];
+        });
+        return [
+          elements.paragraph(
+            { element: block, children: inlines.join("") },
+            blockIndex
+          )
+        ];
+      }
+      default:
+        return [];
+    }
+  });
+  return blocks.join(separator);
 }
 
 // src/crdts/utils.ts
@@ -6761,12 +7979,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _160 => _160.updates, 'access', _161 => _161[key], 'optionalAccess', _162 => _162.type]) === "update") {
+          if (_optionalChain([update, 'access', _186 => _186.updates, 'access', _187 => _187[key], 'optionalAccess', _188 => _188.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _163 => _163.updates, 'access', _164 => _164[key], 'optionalAccess', _165 => _165.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _189 => _189.updates, 'access', _190 => _190[key], 'optionalAccess', _191 => _191.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -6827,12 +8045,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _166 => _166.updates, 'access', _167 => _167[key], 'optionalAccess', _168 => _168.type]) === "update") {
+          if (_optionalChain([update, 'access', _192 => _192.updates, 'access', _193 => _193[key], 'optionalAccess', _194 => _194.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _169 => _169.updates, 'access', _170 => _170[key], 'optionalAccess', _171 => _171.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _195 => _195.updates, 'access', _196 => _196[key], 'optionalAccess', _197 => _197.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -6864,161 +8082,6 @@ function legacy_patchImmutableNode(state, path, update) {
   }
 }
 
-// src/lib/shallow.ts
-function shallowArray(xs, ys) {
-  if (xs.length !== ys.length) {
-    return false;
-  }
-  for (let i = 0; i < xs.length; i++) {
-    if (!Object.is(xs[i], ys[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-function shallowObj(objA, objB) {
-  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null || Object.prototype.toString.call(objA) !== "[object Object]" || Object.prototype.toString.call(objB) !== "[object Object]") {
-    return false;
-  }
-  const keysA = Object.keys(objA);
-  if (keysA.length !== Object.keys(objB).length) {
-    return false;
-  }
-  return keysA.every(
-    (key) => Object.prototype.hasOwnProperty.call(objB, key) && Object.is(objA[key], objB[key])
-  );
-}
-function shallow(a, b) {
-  if (Object.is(a, b)) {
-    return true;
-  }
-  const isArrayA = Array.isArray(a);
-  const isArrayB = Array.isArray(b);
-  if (isArrayA || isArrayB) {
-    if (!isArrayA || !isArrayB) {
-      return false;
-    }
-    return shallowArray(a, b);
-  }
-  return shallowObj(a, b);
-}
-
-// src/lib/AsyncCache.ts
-var noop = () => {
-};
-function isShallowEqual(a, b) {
-  if (a.isLoading !== b.isLoading || a.data === void 0 !== (b.data === void 0) || a.error === void 0 !== (b.error === void 0)) {
-    return false;
-  } else {
-    return shallow(a.data, b.data) && shallow(a.error, b.error);
-  }
-}
-function createCacheItem(key, asyncFunction, options) {
-  const $asyncFunction = async () => asyncFunction(key);
-  const context = {
-    isInvalid: true
-  };
-  let state = { isLoading: false };
-  let previousState = { isLoading: false };
-  const eventSource2 = makeEventSource();
-  function notify() {
-    const isEqual = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _172 => _172.isStateEqual]), () => ( isShallowEqual));
-    if (!isEqual(previousState, state)) {
-      previousState = state;
-      eventSource2.notify(state);
-    }
-  }
-  async function resolve() {
-    if (!context.promise) {
-      return;
-    }
-    try {
-      const data = await context.promise;
-      context.isInvalid = false;
-      state = {
-        isLoading: false,
-        data
-      };
-    } catch (error3) {
-      state = {
-        isLoading: false,
-        data: state.data,
-        error: error3
-      };
-    }
-    context.promise = void 0;
-    notify();
-  }
-  async function revalidate() {
-    context.isInvalid = true;
-    return get();
-  }
-  async function get() {
-    if (context.isInvalid) {
-      if (!context.promise) {
-        context.isInvalid = true;
-        context.promise = $asyncFunction();
-        state = { isLoading: true, data: state.data };
-        notify();
-      }
-      await resolve();
-    }
-    return getState();
-  }
-  function getState() {
-    return state;
-  }
-  return {
-    ...eventSource2.observable,
-    get,
-    getState,
-    revalidate
-  };
-}
-function createAsyncCache(asyncFunction, options) {
-  const cache = /* @__PURE__ */ new Map();
-  function create(key) {
-    let cacheItem = cache.get(key);
-    if (cacheItem) {
-      return cacheItem;
-    }
-    cacheItem = createCacheItem(key, asyncFunction, options);
-    cache.set(key, cacheItem);
-    return cacheItem;
-  }
-  function get(key) {
-    return create(key).get();
-  }
-  function getState(key) {
-    return _optionalChain([cache, 'access', _173 => _173.get, 'call', _174 => _174(key), 'optionalAccess', _175 => _175.getState, 'call', _176 => _176()]);
-  }
-  function revalidate(key) {
-    return create(key).revalidate();
-  }
-  function subscribe(key, callback) {
-    return _nullishCoalesce(create(key).subscribe(callback), () => ( noop));
-  }
-  function subscribeOnce(key, callback) {
-    return _nullishCoalesce(create(key).subscribeOnce(callback), () => ( noop));
-  }
-  function has(key) {
-    return cache.has(key);
-  }
-  function clear() {
-    cache.clear();
-  }
-  return {
-    create,
-    get,
-    getState,
-    revalidate,
-    subscribe,
-    subscribeOnce,
-    has,
-    clear
-  };
-}
-
 // src/lib/Poller.ts
 function makePoller(callback) {
   let context = {
@@ -7108,19 +8171,43 @@ function makePoller(callback) {
   };
 }
 
-// src/lib/stringify.ts
-function stringify(object, ...args) {
-  if (typeof object !== "object" || object === null || Array.isArray(object)) {
-    return JSON.stringify(object, ...args);
+// src/lib/shallow.ts
+function shallowArray(xs, ys) {
+  if (xs.length !== ys.length) {
+    return false;
   }
-  const sortedObject = Object.keys(object).sort().reduce(
-    (sortedObject2, key) => {
-      sortedObject2[key] = object[key];
-      return sortedObject2;
-    },
-    {}
+  for (let i = 0; i < xs.length; i++) {
+    if (!Object.is(xs[i], ys[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function shallowObj(objA, objB) {
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null || Object.prototype.toString.call(objA) !== "[object Object]" || Object.prototype.toString.call(objB) !== "[object Object]") {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(objB, key) && Object.is(objA[key], objB[key])
   );
-  return JSON.stringify(sortedObject, ...args);
+}
+function shallow(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB) {
+      return false;
+    }
+    return shallowArray(a, b);
+  }
+  return shallowObj(a, b);
 }
 
 // src/index.ts
@@ -7175,5 +8262,13 @@ detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 
 
 
-exports.ClientMsgCode = ClientMsgCode; exports.CommentsApiError = CommentsApiError; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.cloneLson = cloneLson; exports.console = fancy_console_exports; exports.convertToCommentData = convertToCommentData; exports.convertToCommentUserReaction = convertToCommentUserReaction; exports.convertToThreadData = convertToThreadData; exports.createAsyncCache = createAsyncCache; exports.createClient = createClient; exports.createCommentsApi = createCommentsApi; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.getMentionedIdsFromCommentBody = getMentionedIdsFromCommentBody; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isLiveNode = isLiveNode; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makeEventSource = makeEventSource; exports.makePoller = makePoller; exports.makePosition = makePosition; exports.nn = nn; exports.patchLiveObjectKey = patchLiveObjectKey; exports.raise = raise; exports.shallow = shallow; exports.stringify = stringify; exports.stringifyCommentBody = stringifyCommentBody; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.withTimeout = withTimeout;
+
+
+
+
+
+
+
+
+exports.ClientMsgCode = ClientMsgCode; exports.CommentsApiError = CommentsApiError; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.NotificationsApiError = NotificationsApiError; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.ackOp = ackOp; exports.addReaction = addReaction; exports.applyOptimisticUpdates = applyOptimisticUpdates; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.cloneLson = cloneLson; exports.console = fancy_console_exports; exports.convertToCommentData = convertToCommentData; exports.convertToCommentUserReaction = convertToCommentUserReaction; exports.convertToInboxNotificationData = convertToInboxNotificationData; exports.convertToThreadData = convertToThreadData; exports.createClient = createClient; exports.deleteComment = deleteComment; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.getMentionedIdsFromCommentBody = getMentionedIdsFromCommentBody; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isLiveNode = isLiveNode; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.kInternal = kInternal; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makeEventSource = makeEventSource; exports.makePoller = makePoller; exports.makePosition = makePosition; exports.nn = nn; exports.objectToQuery = objectToQuery; exports.patchLiveObjectKey = patchLiveObjectKey; exports.raise = raise; exports.removeReaction = removeReaction; exports.shallow = shallow; exports.stringify = stringify; exports.stringifyCommentBody = stringifyCommentBody; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.upsertComment = upsertComment; exports.withTimeout = withTimeout;
 //# sourceMappingURL=index.js.map