@liveblocks/core 1.9.8-pre1 → 1.10.0-beta2

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.9.8-pre1";
+var PKG_VERSION = "1.10.0-beta2";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -652,7 +652,6 @@ 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";
@@ -662,7 +661,6 @@ 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["KICKED"] = 4100] = "KICKED";
   WebsocketCloseCodes2[WebsocketCloseCodes2["TOKEN_EXPIRED"] = 4109] = "TOKEN_EXPIRED";
   WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
   return WebsocketCloseCodes2;
@@ -1327,7 +1325,7 @@ function createAuthManager(authOptions) {
     }
     return false;
   }
-  function getCachedToken(requestedScope, roomId) {
+  function getCachedToken(roomOptions) {
     const now = Math.ceil(Date.now() / 1e3);
     for (let i = tokens.length - 1; i >= 0; i--) {
       const token = tokens[i];
@@ -1340,8 +1338,11 @@ function createAuthManager(authOptions) {
       if (token.parsed.k === "id" /* ID_TOKEN */) {
         return token;
       } else if (token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+        if (!roomOptions) {
+          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 (resource.includes("*") && roomOptions.roomId.startsWith(resource.replace("*", "")) || roomOptions.roomId === resource && hasCorrespondingScopes(roomOptions.requestedScope, scopes)) {
             return token;
           }
         }
@@ -1390,18 +1391,27 @@ function createAuthManager(authOptions) {
       "Unexpected authentication type. Must be private or custom."
     );
   }
-  async function getAuthValue(requestedScope, roomId) {
+  async function getAuthValue(roomOptions) {
     if (authentication.type === "public") {
       return { type: "public", publicApiKey: authentication.publicApiKey };
     }
-    const cachedToken = getCachedToken(requestedScope, roomId);
+    const cachedToken = getCachedToken(roomOptions);
     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 (roomOptions) {
+      currentPromise = requestPromises.get(roomOptions.roomId);
+      if (currentPromise === void 0) {
+        currentPromise = makeAuthRequest(roomOptions.roomId);
+        requestPromises.set(roomOptions.roomId, currentPromise);
+      }
+    } else {
+      currentPromise = requestPromises.get("liveblocks-user-token");
+      if (currentPromise === void 0) {
+        currentPromise = makeAuthRequest();
+        requestPromises.set("liveblocks-user-token", currentPromise);
+      }
     }
     try {
       const token = await currentPromise;
@@ -1414,7 +1424,11 @@ function createAuthManager(authOptions) {
       }
       return { type: "secret", token };
     } finally {
-      requestPromises.delete(roomId);
+      if (roomOptions) {
+        requestPromises.delete(roomOptions.roomId);
+      } else {
+        requestPromises.delete("liveblocks-user-token");
+      }
     }
   }
   return {
@@ -1503,6 +1517,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) {
@@ -1632,7 +1649,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",
@@ -1642,7 +1659,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",
@@ -1653,8 +1670,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",
@@ -1713,6 +1730,185 @@ 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 = options?.size ?? DEFAULT_SIZE;
+    this.delay = options?.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 = results?.[index];
+        if (result instanceof Error) {
+          call.reject(result);
+        } else if (result !== void 0) {
+          call.resolve(result);
+        } else {
+          if (Array.isArray(results)) {
+            call.reject(
+              new Error(
+                `Batch callback must return an array of the same length as the number of calls in the batch. Expected ${calls.length}, but got ${results.length}.`
+              )
+            );
+          } else {
+            call.reject(new Error("Batch callback must return an array."));
+          }
+        }
+      });
+    } 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) {
@@ -1746,1016 +1942,612 @@ function errorIf(condition, message) {
   }
 }
 
-// src/comments/comment-body.ts
-function isCommentBodyParagraph(element) {
-  return "type" in element && element.type === "mention";
+// 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 isCommentBodyText(element) {
-  return "text" in element && typeof element.text === "string";
+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 isCommentBodyMention(element) {
-  return "type" in element && element.type === "mention";
+function convertToCommentUserReaction(data) {
+  return {
+    ...data,
+    createdAt: new Date(data.createdAt)
+  };
 }
-function isCommentBodyLink(element) {
-  return "type" in element && element.type === "link";
+function convertToInboxNotificationData(data) {
+  const notifiedAt = new Date(data.notifiedAt);
+  const readAt = data.readAt ? new Date(data.readAt) : null;
+  return {
+    ...data,
+    notifiedAt,
+    readAt
+  };
 }
-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 || !body?.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)) {
-        visitor?.(block);
-      }
+
+// src/notifications.ts
+var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY = 50;
+function createInboxNotificationsApi({
+  baseUrl,
+  authManager,
+  currentUserIdStore,
+  fetcher
+}) {
+  async function fetchJson(endpoint, options) {
+    const authValue = await authManager.getAuthValue();
+    if (authValue.type === "secret" && authValue.token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+      const userId = authValue.token.parsed.uid;
+      currentUserIdStore.set(() => userId);
     }
-    if (type === "all" || type === "inline") {
-      for (const inline of block.children) {
-        if (guard(inline)) {
-          visitor?.(inline);
+    const url = new URL(`/v2/c${endpoint}`, baseUrl);
+    const response = await fetcher(url.toString(), {
+      ...options,
+      headers: {
+        ...options?.headers,
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
+      }
+    });
+    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 {
+          error3 = new NotificationsApiError(
+            response.statusText,
+            response.status
+          );
         }
+        throw error3;
       }
     }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
   }
-}
-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;
+  async function getInboxNotifications(options) {
+    const queryParams = toURLSearchParams({ limit: options?.limit });
+    const json = await fetchJson(`/inbox-notifications?${queryParams.toString()}`);
+    return {
+      threads: json.threads.map((thread) => convertToThreadData(thread)),
+      inboxNotifications: json.inboxNotifications.map(
+        (notification) => convertToInboxNotificationData(notification)
+      )
+    };
   }
-  const userIds = getMentionedIdsFromCommentBody(body);
-  const users = await resolveUsers({
-    userIds
-  });
-  for (const [index, userId] of userIds.entries()) {
-    const user = users?.[index];
-    if (user) {
-      resolvedUsers.set(userId, user);
-    }
+  async function getUnreadInboxNotificationsCount() {
+    const { count } = await fetchJson("/inbox-notifications/count");
+    return count;
   }
-  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([""], []);
+  async function markAllInboxNotificationsAsRead() {
+    await fetchJson("/inbox-notifications/read", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ inboxNotificationIds: "all" })
+    });
   }
-  return new HtmlSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
+  async function markInboxNotificationsAsRead(inboxNotificationIds) {
+    await fetchJson("/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_DELAY }
   );
-}
-function escapeHtml(value) {
-  if (value instanceof HtmlSafeString) {
-    return value.toString();
+  async function markInboxNotificationAsRead(inboxNotificationId) {
+    await batchedMarkInboxNotificationsAsRead.get(inboxNotificationId);
   }
-  if (Array.isArray(value)) {
-    return joinHtml(value).toString();
-  }
-  return String(value).replace(
-    htmlEscapablesRegex,
-    (character) => htmlEscapables[character]
-  );
+  return {
+    getInboxNotifications,
+    getUnreadInboxNotificationsCount,
+    markAllInboxNotificationsAsRead,
+    markInboxNotificationAsRead
+  };
 }
-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 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());
+    }
   }
-};
-function html(strings, ...values) {
-  return new HtmlSafeString(strings, values);
+  return result;
 }
-var markdownEscapables = {
-  _: "\\_",
-  "*": "\\*",
-  "#": "\\#",
-  "`": "\\`",
-  "~": "\\~",
-  "!": "\\!",
-  "|": "\\|",
-  "(": "\\(",
-  ")": "\\)",
-  "{": "\\{",
-  "}": "\\}",
-  "[": "\\[",
-  "]": "\\]"
-};
-var markdownEscapablesRegex = new RegExp(
-  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
-  "g"
-);
-function joinMarkdown(strings) {
-  if (strings.length <= 0) {
-    return new MarkdownSafeString([""], []);
+
+// src/lib/position.ts
+var MIN_CODE = 32;
+var MAX_CODE = 126;
+var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
+var ZERO = nthDigit(0);
+var ONE = nthDigit(1);
+var ZERO_NINE = ZERO + nthDigit(-1);
+function nthDigit(n) {
+  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
+  if (code < MIN_CODE || code > MAX_CODE) {
+    throw new Error(`Invalid n value: ${n}`);
   }
-  return new MarkdownSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
-  );
+  return String.fromCharCode(code);
 }
-function escapeMarkdown(value) {
-  if (value instanceof MarkdownSafeString) {
-    return value.toString();
-  }
-  if (Array.isArray(value)) {
-    return joinMarkdown(value).toString();
+function makePosition(x, y) {
+  if (x !== void 0 && y !== void 0) {
+    return between(x, y);
+  } else if (x !== void 0) {
+    return after(x);
+  } else if (y !== void 0) {
+    return before(y);
+  } else {
+    return ONE;
   }
-  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 before(pos) {
+  const lastIndex = pos.length - 1;
+  for (let i = 0; i <= lastIndex; i++) {
+    const code = pos.charCodeAt(i);
+    if (code <= MIN_CODE) {
+      continue;
+    }
+    if (i === lastIndex) {
+      if (code === MIN_CODE + 1) {
+        return pos.substring(0, i) + ZERO_NINE;
+      } else {
+        return pos.substring(0, i) + String.fromCharCode(code - 1);
+      }
+    } else {
+      return pos.substring(0, i + 1);
+    }
   }
-};
-function markdown(strings, ...values) {
-  return new MarkdownSafeString(strings, values);
+  return ONE;
 }
-function toAbsoluteUrl(url) {
-  if (url.startsWith("http://") || url.startsWith("https://")) {
-    return url;
-  } else if (url.startsWith("www.")) {
-    return "https://" + url;
+function after(pos) {
+  for (let i = 0; i <= pos.length - 1; i++) {
+    const code = pos.charCodeAt(i);
+    if (code >= MAX_CODE) {
+      continue;
+    }
+    return pos.substring(0, i) + String.fromCharCode(code + 1);
   }
-  return;
+  return pos + ONE;
 }
-var stringifyCommentBodyPlainElements = {
-  paragraph: ({ children }) => children,
-  text: ({ element }) => element.text,
-  link: ({ element }) => element.url,
-  mention: ({ element, user }) => {
-    return `@${user?.name ?? element.id}`;
+function between(lo, hi) {
+  if (lo < hi) {
+    return _between(lo, hi);
+  } else if (lo > hi) {
+    return _between(hi, lo);
+  } else {
+    throw new Error("Cannot compute value between two equal positions");
   }
-};
-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>`;
+}
+function _between(lo, hi) {
+  let index = 0;
+  const loLen = lo.length;
+  const hiLen = hi.length;
+  while (true) {
+    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
+    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
+    if (loCode === hiCode) {
+      index++;
+      continue;
     }
-    if (element.code) {
-      children = html`<code>${children}</code>`;
+    if (hiCode - loCode === 1) {
+      const size = index + 1;
+      let prefix = lo.substring(0, size);
+      if (prefix.length < size) {
+        prefix += ZERO.repeat(size - prefix.length);
+      }
+      const suffix = lo.substring(size);
+      const nines = "";
+      return prefix + _between(suffix, nines);
+    } else {
+      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
     }
-    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>@${user?.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 (element.italic) {
-      children = markdown`_${children}_`;
-    }
-    if (element.strikethrough) {
-      children = markdown`~~${children}~~`;
-    }
-    if (element.code) {
-      children = markdown`\`${children}\``;
+}
+function takeN(pos, n) {
+  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
+}
+var MIN_NON_ZERO_CODE = MIN_CODE + 1;
+function isPos(str) {
+  if (str === "") {
+    return false;
+  }
+  const lastIdx = str.length - 1;
+  const last = str.charCodeAt(lastIdx);
+  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
+    return false;
+  }
+  for (let i = 0; i < lastIdx; i++) {
+    const code = str.charCodeAt(i);
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return false;
     }
-    return children;
-  },
-  link: ({ element, href }) => {
-    return markdown`[${element.url}](${href})`;
-  },
-  mention: ({ element, user }) => {
-    return markdown`@${user?.name ?? element.id}`;
   }
-};
-async function stringifyCommentBody(body, options) {
-  const format = options?.format ?? "plain";
-  const separator = options?.separator ?? (format === "markdown" ? "\n\n" : "\n");
-  const elements = {
-    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ...options?.elements
-  };
-  const resolvedUsers = await resolveUsersInCommentBody(
-    body,
-    options?.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: 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);
+  return true;
 }
-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 convertToPos(str) {
+  const codes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
   }
-}
-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)
+  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
+    codes.length--;
+  }
+  return codes.length > 0 ? String.fromCharCode(...codes) : (
+    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
+    ONE
   );
-  return {
-    ...data,
-    createdAt,
-    updatedAt,
-    comments
-  };
 }
-function convertToCommentUserReaction(data) {
+function asPos(str) {
+  return isPos(str) ? str : convertToPos(str);
+}
+
+// src/protocol/Op.ts
+var OpCode = /* @__PURE__ */ ((OpCode2) => {
+  OpCode2[OpCode2["INIT"] = 0] = "INIT";
+  OpCode2[OpCode2["SET_PARENT_KEY"] = 1] = "SET_PARENT_KEY";
+  OpCode2[OpCode2["CREATE_LIST"] = 2] = "CREATE_LIST";
+  OpCode2[OpCode2["UPDATE_OBJECT"] = 3] = "UPDATE_OBJECT";
+  OpCode2[OpCode2["CREATE_OBJECT"] = 4] = "CREATE_OBJECT";
+  OpCode2[OpCode2["DELETE_CRDT"] = 5] = "DELETE_CRDT";
+  OpCode2[OpCode2["DELETE_OBJECT_KEY"] = 6] = "DELETE_OBJECT_KEY";
+  OpCode2[OpCode2["CREATE_MAP"] = 7] = "CREATE_MAP";
+  OpCode2[OpCode2["CREATE_REGISTER"] = 8] = "CREATE_REGISTER";
+  return OpCode2;
+})(OpCode || {});
+function ackOp(opId) {
   return {
-    ...data,
-    createdAt: new Date(data.createdAt)
+    type: 5 /* DELETE_CRDT */,
+    id: "ACK",
+    // (H)ACK
+    opId
   };
 }
+function isAckOp(op) {
+  return op.type === 5 /* DELETE_CRDT */ && op.id === "ACK";
+}
 
-// src/comments/index.ts
-function getAuthBearerHeaderFromAuthValue(authValue) {
-  if (authValue.type === "public") {
-    return authValue.publicApiKey;
-  } else {
-    return authValue.token.raw;
-  }
+// src/crdts/AbstractCrdt.ts
+function crdtAsLiveNode(value) {
+  return value;
 }
-var CommentsApiError = class extends Error {
-  constructor(message, status, details) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.details = details;
+function HasParent(node, key, pos = asPos(key)) {
+  return Object.freeze({ type: "HasParent", node, key, pos });
+}
+var NoParent = Object.freeze({ type: "NoParent" });
+function Orphaned(oldKey, oldPos = asPos(oldKey)) {
+  return Object.freeze({ type: "Orphaned", oldKey, oldPos });
+}
+var AbstractCrdt = class {
+  constructor() {
+    /** @internal */
+    this._parent = NoParent;
   }
-};
-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(
-            errorBody.message,
-            response.status,
-            errorBody
-          );
-        } catch {
-          error3 = new CommentsApiError(response.statusText, response.status);
-        }
-        throw error3;
-      }
+  /** @internal */
+  _getParentKeyOrThrow() {
+    switch (this.parent.type) {
+      case "HasParent":
+        return this.parent.key;
+      case "NoParent":
+        throw new Error("Parent key is missing");
+      case "Orphaned":
+        return this.parent.oldKey;
+      default:
+        return assertNever(this.parent, "Unknown state");
     }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = {};
+  }
+  /** @internal */
+  get _parentPos() {
+    switch (this.parent.type) {
+      case "HasParent":
+        return this.parent.pos;
+      case "NoParent":
+        throw new Error("Parent key is missing");
+      case "Orphaned":
+        return this.parent.oldPos;
+      default:
+        return assertNever(this.parent, "Unknown state");
     }
-    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: {
-        ...options?.headers,
-        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
-      }
-    });
+  /** @internal */
+  get _pool() {
+    return this.__pool;
   }
-  async function getThreads(options) {
-    const response = await fetchApi(roomId, "/threads/search", {
-      body: JSON.stringify({
-        ...options?.query?.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.");
-    }
+  get roomId() {
+    return this.__pool ? this.__pool.roomId : null;
   }
-  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);
+  /** @internal */
+  get _id() {
+    return this.__id;
   }
-  async function editThreadMetadata({
-    metadata,
-    threadId
-  }) {
-    return await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
-    );
+  /** @internal */
+  get parent() {
+    return this._parent;
   }
-  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);
+  /** @internal */
+  get _parentKey() {
+    switch (this.parent.type) {
+      case "HasParent":
+        return this.parent.key;
+      case "NoParent":
+        return null;
+      case "Orphaned":
+        return this.parent.oldKey;
+      default:
+        return assertNever(this.parent, "Unknown state");
+    }
   }
-  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
-        })
+  /** @internal */
+  _apply(op, _isLocal) {
+    switch (op.type) {
+      case 5 /* DELETE_CRDT */: {
+        if (this.parent.type === "HasParent") {
+          return this.parent.node._detachChild(crdtAsLiveNode(this));
+        }
+        return { modified: false };
       }
-    );
-    return convertToCommentData(comment);
+    }
+    return { modified: false };
   }
-  async function deleteComment({
-    threadId,
-    commentId
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "DELETE"
+  /** @internal */
+  _setParentLink(newParentNode, newParentKey) {
+    switch (this.parent.type) {
+      case "HasParent":
+        if (this.parent.node !== newParentNode) {
+          throw new Error("Cannot set parent: node already has a parent");
+        } else {
+          this._parent = HasParent(newParentNode, newParentKey);
+          return;
+        }
+      case "Orphaned":
+      case "NoParent": {
+        this._parent = HasParent(newParentNode, newParentKey);
+        return;
       }
-    );
+      default:
+        return assertNever(this.parent, "Unknown state");
+    }
   }
-  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);
+  /** @internal */
+  _attach(id, pool) {
+    if (this.__id || this.__pool) {
+      throw new Error("Cannot attach node: already attached");
+    }
+    pool.addNode(id, crdtAsLiveNode(this));
+    this.__id = id;
+    this.__pool = pool;
   }
-  async function removeReaction({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions/${encodeURIComponent(emoji)}`,
-      {
-        method: "DELETE"
+  /** @internal */
+  _detach() {
+    if (this.__pool && this.__id) {
+      this.__pool.deleteNode(this.__id);
+    }
+    switch (this.parent.type) {
+      case "HasParent": {
+        this._parent = Orphaned(this.parent.key, this.parent.pos);
+        break;
       }
-    );
-  }
-  return {
-    getThreads,
-    createThread,
-    editThreadMetadata,
-    createComment,
-    editComment,
-    deleteComment,
-    addReaction,
-    removeReaction
-  };
-}
-
-// src/lib/position.ts
-var MIN_CODE = 32;
-var MAX_CODE = 126;
-var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
-var ZERO = nthDigit(0);
-var ONE = nthDigit(1);
-var ZERO_NINE = ZERO + nthDigit(-1);
-function nthDigit(n) {
-  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
-  if (code < MIN_CODE || code > MAX_CODE) {
-    throw new Error(`Invalid n value: ${n}`);
-  }
-  return String.fromCharCode(code);
-}
-function makePosition(x, y) {
-  if (x !== void 0 && y !== void 0) {
-    return between(x, y);
-  } else if (x !== void 0) {
-    return after(x);
-  } else if (y !== void 0) {
-    return before(y);
-  } else {
-    return ONE;
-  }
-}
-function before(pos) {
-  const lastIndex = pos.length - 1;
-  for (let i = 0; i <= lastIndex; i++) {
-    const code = pos.charCodeAt(i);
-    if (code <= MIN_CODE) {
-      continue;
+      case "NoParent": {
+        this._parent = NoParent;
+        break;
+      }
+      case "Orphaned": {
+        break;
+      }
+      default:
+        assertNever(this.parent, "Unknown state");
     }
-    if (i === lastIndex) {
-      if (code === MIN_CODE + 1) {
-        return pos.substring(0, i) + ZERO_NINE;
-      } else {
-        return pos.substring(0, i) + String.fromCharCode(code - 1);
+    this.__pool = void 0;
+  }
+  /**
+   * @internal
+   *
+   * Clear the Immutable cache, so that the next call to `.toImmutable()` will
+   * recompute the equivalent Immutable value again.  Call this after every
+   * mutation to the Live node.
+   */
+  invalidate() {
+    if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
+      this._cachedImmutable = void 0;
+      this._cachedTreeNode = void 0;
+      if (this.parent.type === "HasParent") {
+        this.parent.node.invalidate();
       }
-    } else {
-      return pos.substring(0, i + 1);
     }
   }
-  return ONE;
-}
-function after(pos) {
-  for (let i = 0; i <= pos.length - 1; i++) {
-    const code = pos.charCodeAt(i);
-    if (code >= MAX_CODE) {
-      continue;
+  /**
+   * @internal
+   *
+   * Return an snapshot of this Live tree for use in DevTools.
+   */
+  toTreeNode(key) {
+    if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
+      this._cachedTreeNodeKey = key;
+      this._cachedTreeNode = this._toTreeNode(key);
     }
-    return pos.substring(0, i) + String.fromCharCode(code + 1);
+    return this._cachedTreeNode;
   }
-  return pos + ONE;
-}
-function between(lo, hi) {
-  if (lo < hi) {
-    return _between(lo, hi);
-  } else if (lo > hi) {
-    return _between(hi, lo);
-  } else {
-    throw new Error("Cannot compute value between two equal positions");
+  /**
+   * Return an immutable snapshot of this Live node and its children.
+   */
+  toImmutable() {
+    if (this._cachedImmutable === void 0) {
+      this._cachedImmutable = this._toImmutable();
+    }
+    return this._cachedImmutable;
   }
+};
+
+// src/protocol/SerializedCrdt.ts
+var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
+  CrdtType2[CrdtType2["OBJECT"] = 0] = "OBJECT";
+  CrdtType2[CrdtType2["LIST"] = 1] = "LIST";
+  CrdtType2[CrdtType2["MAP"] = 2] = "MAP";
+  CrdtType2[CrdtType2["REGISTER"] = 3] = "REGISTER";
+  return CrdtType2;
+})(CrdtType || {});
+function isRootCrdt(crdt) {
+  return crdt.type === 0 /* OBJECT */ && !isChildCrdt(crdt);
 }
-function _between(lo, hi) {
-  let index = 0;
-  const loLen = lo.length;
-  const hiLen = hi.length;
-  while (true) {
-    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
-    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
-    if (loCode === hiCode) {
-      index++;
-      continue;
-    }
-    if (hiCode - loCode === 1) {
-      const size = index + 1;
-      let prefix = lo.substring(0, size);
-      if (prefix.length < size) {
-        prefix += ZERO.repeat(size - prefix.length);
-      }
-      const suffix = lo.substring(size);
-      const nines = "";
-      return prefix + _between(suffix, nines);
-    } else {
-      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
-    }
-  }
-}
-function takeN(pos, n) {
-  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
-}
-var MIN_NON_ZERO_CODE = MIN_CODE + 1;
-function isPos(str) {
-  if (str === "") {
-    return false;
-  }
-  const lastIdx = str.length - 1;
-  const last = str.charCodeAt(lastIdx);
-  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
-    return false;
-  }
-  for (let i = 0; i < lastIdx; i++) {
-    const code = str.charCodeAt(i);
-    if (code < MIN_CODE || code > MAX_CODE) {
-      return false;
-    }
-  }
-  return true;
-}
-function convertToPos(str) {
-  const codes = [];
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
-  }
-  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
-    codes.length--;
-  }
-  return codes.length > 0 ? String.fromCharCode(...codes) : (
-    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
-    ONE
-  );
-}
-function asPos(str) {
-  return isPos(str) ? str : convertToPos(str);
+function isChildCrdt(crdt) {
+  return crdt.parentId !== void 0 && crdt.parentKey !== void 0;
 }
 
-// src/protocol/Op.ts
-var OpCode = /* @__PURE__ */ ((OpCode2) => {
-  OpCode2[OpCode2["INIT"] = 0] = "INIT";
-  OpCode2[OpCode2["SET_PARENT_KEY"] = 1] = "SET_PARENT_KEY";
-  OpCode2[OpCode2["CREATE_LIST"] = 2] = "CREATE_LIST";
-  OpCode2[OpCode2["UPDATE_OBJECT"] = 3] = "UPDATE_OBJECT";
-  OpCode2[OpCode2["CREATE_OBJECT"] = 4] = "CREATE_OBJECT";
-  OpCode2[OpCode2["DELETE_CRDT"] = 5] = "DELETE_CRDT";
-  OpCode2[OpCode2["DELETE_OBJECT_KEY"] = 6] = "DELETE_OBJECT_KEY";
-  OpCode2[OpCode2["CREATE_MAP"] = 7] = "CREATE_MAP";
-  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";
+// src/lib/nanoid.ts
+function nanoid(length = 7) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,./;[]~!@#$%&*()_+=-";
+  const len = alphabet.length;
+  return Array.from(
+    { length },
+    () => alphabet.charAt(Math.floor(Math.random() * len))
+  ).join("");
 }
 
-// src/crdts/AbstractCrdt.ts
-function crdtAsLiveNode(value) {
-  return value;
-}
-function HasParent(node, key, pos = asPos(key)) {
-  return Object.freeze({ type: "HasParent", node, key, pos });
-}
-var NoParent = Object.freeze({ type: "NoParent" });
-function Orphaned(oldKey, oldPos = asPos(oldKey)) {
-  return Object.freeze({ type: "Orphaned", oldKey, oldPos });
-}
-var AbstractCrdt = class {
-  constructor() {
-    /** @internal */
-    this._parent = NoParent;
+// src/crdts/LiveRegister.ts
+var LiveRegister = class _LiveRegister extends AbstractCrdt {
+  constructor(data) {
+    super();
+    this._data = data;
+  }
+  get data() {
+    return this._data;
   }
   /** @internal */
-  _getParentKeyOrThrow() {
-    switch (this.parent.type) {
-      case "HasParent":
-        return this.parent.key;
-      case "NoParent":
-        throw new Error("Parent key is missing");
-      case "Orphaned":
-        return this.parent.oldKey;
-      default:
-        return assertNever(this.parent, "Unknown state");
-    }
+  static _deserialize([id, item], _parentToChildren, pool) {
+    const register = new _LiveRegister(item.data);
+    register._attach(id, pool);
+    return register;
   }
   /** @internal */
-  get _parentPos() {
-    switch (this.parent.type) {
-      case "HasParent":
-        return this.parent.pos;
-      case "NoParent":
-        throw new Error("Parent key is missing");
-      case "Orphaned":
-        return this.parent.oldPos;
-      default:
-        return assertNever(this.parent, "Unknown state");
+  _toOps(parentId, parentKey, pool) {
+    if (this._id === void 0) {
+      throw new Error(
+        "Cannot serialize register if parentId or parentKey is undefined"
+      );
     }
+    return [
+      {
+        type: 8 /* CREATE_REGISTER */,
+        opId: pool?.generateOpId(),
+        id: this._id,
+        parentId,
+        parentKey,
+        data: this.data
+      }
+    ];
   }
   /** @internal */
-  get _pool() {
-    return this.__pool;
-  }
-  get roomId() {
-    return this.__pool ? this.__pool.roomId : null;
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveRegister if parent is missing");
+    }
+    return {
+      type: 3 /* REGISTER */,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key,
+      data: this.data
+    };
   }
   /** @internal */
-  get _id() {
-    return this.__id;
+  _attachChild(_op) {
+    throw new Error("Method not implemented.");
   }
   /** @internal */
-  get parent() {
-    return this._parent;
+  _detachChild(_crdt) {
+    throw new Error("Method not implemented.");
   }
   /** @internal */
-  get _parentKey() {
-    switch (this.parent.type) {
-      case "HasParent":
-        return this.parent.key;
-      case "NoParent":
-        return null;
-      case "Orphaned":
-        return this.parent.oldKey;
-      default:
-        return assertNever(this.parent, "Unknown state");
-    }
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
   }
   /** @internal */
-  _apply(op, _isLocal) {
-    switch (op.type) {
-      case 5 /* DELETE_CRDT */: {
-        if (this.parent.type === "HasParent") {
-          return this.parent.node._detachChild(crdtAsLiveNode(this));
-        }
-        return { modified: false };
-      }
-    }
-    return { modified: false };
+  _toTreeNode(key) {
+    return {
+      type: "Json",
+      id: this._id ?? nanoid(),
+      key,
+      payload: this._data
+    };
   }
   /** @internal */
-  _setParentLink(newParentNode, newParentKey) {
-    switch (this.parent.type) {
-      case "HasParent":
-        if (this.parent.node !== newParentNode) {
-          throw new Error("Cannot set parent: node already has a parent");
-        } else {
-          this._parent = HasParent(newParentNode, newParentKey);
-          return;
-        }
-      case "Orphaned":
-      case "NoParent": {
-        this._parent = HasParent(newParentNode, newParentKey);
-        return;
-      }
-      default:
-        return assertNever(this.parent, "Unknown state");
-    }
-  }
-  /** @internal */
-  _attach(id, pool) {
-    if (this.__id || this.__pool) {
-      throw new Error("Cannot attach node: already attached");
-    }
-    pool.addNode(id, crdtAsLiveNode(this));
-    this.__id = id;
-    this.__pool = pool;
-  }
-  /** @internal */
-  _detach() {
-    if (this.__pool && this.__id) {
-      this.__pool.deleteNode(this.__id);
-    }
-    switch (this.parent.type) {
-      case "HasParent": {
-        this._parent = Orphaned(this.parent.key, this.parent.pos);
-        break;
-      }
-      case "NoParent": {
-        this._parent = NoParent;
-        break;
-      }
-      case "Orphaned": {
-        break;
-      }
-      default:
-        assertNever(this.parent, "Unknown state");
-    }
-    this.__pool = void 0;
-  }
-  /**
-   * @internal
-   *
-   * Clear the Immutable cache, so that the next call to `.toImmutable()` will
-   * recompute the equivalent Immutable value again.  Call this after every
-   * mutation to the Live node.
-   */
-  invalidate() {
-    if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
-      this._cachedImmutable = void 0;
-      this._cachedTreeNode = void 0;
-      if (this.parent.type === "HasParent") {
-        this.parent.node.invalidate();
-      }
-    }
-  }
-  /**
-   * @internal
-   *
-   * Return an snapshot of this Live tree for use in DevTools.
-   */
-  toTreeNode(key) {
-    if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
-      this._cachedTreeNodeKey = key;
-      this._cachedTreeNode = this._toTreeNode(key);
-    }
-    return this._cachedTreeNode;
-  }
-  /**
-   * Return an immutable snapshot of this Live node and its children.
-   */
-  toImmutable() {
-    if (this._cachedImmutable === void 0) {
-      this._cachedImmutable = this._toImmutable();
-    }
-    return this._cachedImmutable;
-  }
-};
-
-// src/protocol/SerializedCrdt.ts
-var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
-  CrdtType2[CrdtType2["OBJECT"] = 0] = "OBJECT";
-  CrdtType2[CrdtType2["LIST"] = 1] = "LIST";
-  CrdtType2[CrdtType2["MAP"] = 2] = "MAP";
-  CrdtType2[CrdtType2["REGISTER"] = 3] = "REGISTER";
-  return CrdtType2;
-})(CrdtType || {});
-function isRootCrdt(crdt) {
-  return crdt.type === 0 /* OBJECT */ && !isChildCrdt(crdt);
-}
-function isChildCrdt(crdt) {
-  return crdt.parentId !== void 0 && crdt.parentKey !== void 0;
-}
-
-// src/lib/nanoid.ts
-function nanoid(length = 7) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,./;[]~!@#$%&*()_+=-";
-  const len = alphabet.length;
-  return Array.from(
-    { length },
-    () => alphabet.charAt(Math.floor(Math.random() * len))
-  ).join("");
-}
-
-// src/crdts/LiveRegister.ts
-var LiveRegister = class _LiveRegister extends AbstractCrdt {
-  constructor(data) {
-    super();
-    this._data = data;
-  }
-  get data() {
-    return this._data;
-  }
-  /** @internal */
-  static _deserialize([id, item], _parentToChildren, pool) {
-    const register = new _LiveRegister(item.data);
-    register._attach(id, pool);
-    return register;
-  }
-  /** @internal */
-  _toOps(parentId, parentKey, pool) {
-    if (this._id === void 0) {
-      throw new Error(
-        "Cannot serialize register if parentId or parentKey is undefined"
-      );
-    }
-    return [
-      {
-        type: 8 /* CREATE_REGISTER */,
-        opId: pool?.generateOpId(),
-        id: this._id,
-        parentId,
-        parentKey,
-        data: this.data
-      }
-    ];
-  }
-  /** @internal */
-  _serialize() {
-    if (this.parent.type !== "HasParent") {
-      throw new Error("Cannot serialize LiveRegister if parent is missing");
-    }
-    return {
-      type: 3 /* REGISTER */,
-      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-      parentKey: this.parent.key,
-      data: this.data
-    };
-  }
-  /** @internal */
-  _attachChild(_op) {
-    throw new Error("Method not implemented.");
-  }
-  /** @internal */
-  _detachChild(_crdt) {
-    throw new Error("Method not implemented.");
-  }
-  /** @internal */
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
-  }
-  /** @internal */
-  _toTreeNode(key) {
-    return {
-      type: "Json",
-      id: this._id ?? nanoid(),
-      key,
-      payload: this._data
-    };
-  }
-  /** @internal */
-  _toImmutable() {
-    return this._data;
-  }
-  clone() {
-    return deepClone(this.data);
-  }
-};
-
-// src/crdts/LiveList.ts
-function compareNodePosition(itemA, itemB) {
-  const posA = itemA._parentPos;
-  const posB = itemB._parentPos;
-  return posA === posB ? 0 : posA < posB ? -1 : 1;
-}
-var LiveList = class _LiveList extends AbstractCrdt {
-  constructor(items = []) {
-    super();
-    this._items = [];
-    this._implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
-    this._unacknowledgedSets = /* @__PURE__ */ new Map();
-    let position = void 0;
-    for (const item of items) {
-      const newPosition = makePosition(position);
-      const node = lsonToLiveNode(item);
-      node._setParentLink(this, newPosition);
-      this._items.push(node);
-      position = newPosition;
+  _toImmutable() {
+    return this._data;
+  }
+  clone() {
+    return deepClone(this.data);
+  }
+};
+
+// src/crdts/LiveList.ts
+function compareNodePosition(itemA, itemB) {
+  const posA = itemA._parentPos;
+  const posB = itemB._parentPos;
+  return posA === posB ? 0 : posA < posB ? -1 : 1;
+}
+var LiveList = class _LiveList extends AbstractCrdt {
+  constructor(items = []) {
+    super();
+    this._items = [];
+    this._implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
+    this._unacknowledgedSets = /* @__PURE__ */ new Map();
+    let position = void 0;
+    for (const item of items) {
+      const newPosition = makePosition(position);
+      const node = lsonToLiveNode(item);
+      node._setParentLink(this, newPosition);
+      this._items.push(node);
+      position = newPosition;
     }
   }
   /** @internal */
@@ -5158,54 +4950,272 @@ function installBackgroundTabSpy() {
   };
   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";
-    }
-  };
-  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",
-          data: initialPresence
+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, options) {
+    const authValue = await getAuthValue();
+    return fetchClientApi(roomId, endpoint, authValue, options);
+  }
+  async function fetchJson(endpoint, options) {
+    const response = await fetchCommentsApi(endpoint, 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 {
+          error3 = new CommentsApiError(response.statusText, response.status);
         }
-      ),
-      messages: [],
-      storageOperations: []
-    },
-    staticSessionInfo: new ValueRef(null),
-    dynamicSessionInfo: new ValueRef(null),
-    myPresence: new PatchableRef(initialPresence),
-    others: new OthersRef(),
-    initialStorage,
-    idFactory: null,
-    // Storage
-    clock: 0,
-    opClock: 0,
-    nodes: /* @__PURE__ */ new Map(),
-    root: void 0,
-    undoStack: [],
+        throw error3;
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  async function getThreads(options) {
+    const response = await fetchCommentsApi("/threads/search", {
+      body: JSON.stringify({
+        ...options?.query?.metadata && { metadata: options.query.metadata }
+      }),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: json.data.map((thread) => convertToThreadData(thread)),
+        inboxNotifications: json.inboxNotifications.map(
+          (notification) => convertToInboxNotificationData(notification)
+        )
+      };
+    } else if (response.status === 404) {
+      return { threads: [], inboxNotifications: [] };
+    } 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 deleteComment({
+    threadId,
+    commentId
+  }) {
+    await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  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 removeReaction({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  return {
+    getThreads,
+    getThread,
+    createThread,
+    editThreadMetadata,
+    createComment,
+    editComment,
+    deleteComment,
+    addReaction,
+    removeReaction
+  };
+}
+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",
+          data: initialPresence
+        }
+      ),
+      messages: [],
+      storageOperations: []
+    },
+    staticSessionInfo: new ValueRef(null),
+    dynamicSessionInfo: new ValueRef(null),
+    myPresence: new PatchableRef(initialPresence),
+    others: new OthersRef(),
+    initialStorage,
+    idFactory: null,
+    // Storage
+    clock: 0,
+    opClock: 0,
+    nodes: /* @__PURE__ */ new Map(),
+    root: void 0,
+    undoStack: [],
     redoStack: [],
     pausedHistory: null,
     activeBatch: null,
@@ -5219,7 +5229,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") {
@@ -5373,18 +5383,26 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
-  async function streamFetch(authTokenOrPublicApiKey, roomId) {
+  async function fetchClientApi(roomId, endpoint, authValue, options2) {
     const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(roomId)}/storage`,
+      `/v2/c/rooms/${encodeURIComponent(roomId)}${endpoint}`,
       config.baseUrl
-    ).toString();
+    );
     const fetcher = config.polyfills?.fetch || /* istanbul ignore next */
     fetch;
-    return fetcher(url.toString(), {
+    return await fetcher(url.toString(), {
+      ...options2,
+      headers: {
+        ...options2?.headers,
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
+      }
+    });
+  }
+  async function streamFetch(authValue, roomId) {
+    return fetchClientApi(roomId, "/storage", authValue, {
       method: "GET",
       headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authTokenOrPublicApiKey}`
+        "Content-Type": "application/json"
       }
     });
   }
@@ -5392,18 +5410,10 @@ function createRoom(options, config) {
     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 = config.polyfills?.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)
     });
@@ -6017,10 +6027,7 @@ ${Array.from(traces).join("\n\n")}`
     if (!managedSocket.authValue) {
       return;
     }
-    const result = await streamFetch(
-      managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw,
-      config.roomId
-    );
+    const result = await streamFetch(managedSocket.authValue, config.roomId);
     const items = await result.json();
     processInitialStorage({ type: 200 /* INITIAL_STORAGE_STATE */, items });
   }
@@ -6206,27 +6213,71 @@ ${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(context.buffer.presenceUpdates?.data ?? null);
-        },
-        // prettier-ignore
-        get undoStack() {
-          return deepClone(context.undoStack);
-        },
-        // prettier-ignore
-        get nodeCount() {
-          return context.nodes.size;
-        },
-        // prettier-ignore
-        // Support for the Liveblocks browser extension
-        getSelf_forDevTools: () => selfAsTreeNode.current,
+  const commentsApi = createCommentsApi(
+    config.roomId,
+    delegates.authenticate,
+    fetchClientApi
+  );
+  async function fetchJson(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 errorMessage = "";
+        try {
+          const errorBody = await response.json();
+          errorMessage = errorBody.message;
+        } catch (error3) {
+          errorMessage = response.statusText;
+        }
+        throw new Error(
+          `Request failed with status ${response.status}: ${errorMessage}`
+        );
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  function getRoomNotificationSettings() {
+    return fetchJson("/notification-settings");
+  }
+  function updateRoomNotificationSettings(settings) {
+    return fetchJson("/notification-settings", {
+      method: "POST",
+      body: JSON.stringify(settings),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  return Object.defineProperty(
+    {
+      /* NOTE: Exposing internals here only to allow testing implementation details in unit tests */
+      [kInternal]: {
+        get presenceBuffer() {
+          return deepClone(context.buffer.presenceUpdates?.data ?? null);
+        },
+        // prettier-ignore
+        get undoStack() {
+          return deepClone(context.undoStack);
+        },
+        // prettier-ignore
+        get nodeCount() {
+          return context.nodes.size;
+        },
+        // prettier-ignore
+        // Support for the Liveblocks browser extension
+        getSelf_forDevTools: () => selfAsTreeNode.current,
         getOthers_forDevTools: () => others_forDevTools.current,
         // prettier-ignore
         simulate: {
@@ -6271,11 +6322,15 @@ ${Array.from(traces).join("\n\n")}`
       // Presence
       getPresence: () => context.myPresence.current,
       getOthers: () => context.others.current,
-      ...commentsApi
+      // Comments
+      ...commentsApi,
+      // Notifications
+      getRoomNotificationSettings,
+      updateRoomNotificationSettings
     },
-    // 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 }
   );
 }
@@ -6375,7 +6430,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) {
@@ -6402,6 +6457,327 @@ function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
   };
 }
 
+// src/store.ts
+function createClientStore() {
+  const store = createStore({
+    threads: {},
+    queries: {},
+    optimisticUpdates: [],
+    inboxNotifications: {},
+    notificationSettings: {}
+  });
+  function mergeThreads(existingThreads, newThreads) {
+    const updatedThreads = { ...existingThreads };
+    Object.entries(newThreads).forEach(([id, thread]) => {
+      const existingThread = updatedThreads[id];
+      if (existingThread) {
+        const result = compareThreads(existingThread, thread);
+        if (result === 1)
+          return;
+      }
+      updatedThreads[id] = thread;
+    });
+    return updatedThreads;
+  }
+  function mergeNotifications(existingInboxNotifications, newInboxNotifications) {
+    const inboxNotifications = Object.values({
+      ...existingInboxNotifications,
+      ...newInboxNotifications
+    });
+    return Object.fromEntries(
+      inboxNotifications.map((notification) => [notification.id, notification])
+    );
+  }
+  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.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, queryKey) {
+      store.set((state) => ({
+        ...state,
+        threads: mergeThreads(
+          state.threads,
+          Object.fromEntries(threads.map((thread) => [thread.id, thread]))
+        ),
+        inboxNotifications: mergeNotifications(
+          state.inboxNotifications,
+          Object.fromEntries(
+            inboxNotifications.map((notification) => [
+              notification.id,
+              notification
+            ])
+          )
+        ),
+        queries: queryKey !== void 0 ? {
+          ...state.queries,
+          [queryKey]: {
+            isLoading: false
+          }
+        } : state.queries
+      }));
+    },
+    pushOptimisticUpdate(optimisticUpdate) {
+      store.set((state) => ({
+        ...state,
+        optimisticUpdates: [...state.optimisticUpdates, optimisticUpdate]
+      }));
+    },
+    setQueryState(queryKey, queryState) {
+      store.set((state) => ({
+        ...state,
+        queries: {
+          ...state.queries,
+          [queryKey]: queryState
+        }
+      }));
+    }
+  };
+}
+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;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          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] = {
+          ...thread,
+          comments: [...thread.comments, optimisticUpdate.comment]
+          // TODO: Handle replace comment
+        };
+        if (!optimisticUpdate.inboxNotificationId) {
+          break;
+        }
+        const inboxNotification = result.inboxNotifications[optimisticUpdate.inboxNotificationId];
+        result.inboxNotifications[optimisticUpdate.inboxNotificationId] = {
+          ...inboxNotification,
+          notifiedAt: optimisticUpdate.comment.createdAt,
+          readAt: optimisticUpdate.comment.createdAt
+        };
+        break;
+      }
+      case "edit-comment": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          comments: thread.comments.map(
+            (comment) => comment.id === optimisticUpdate.commentId ? {
+              ...comment,
+              editedAt: optimisticUpdate.editedAt,
+              body: optimisticUpdate.body
+            } : comment
+          )
+        };
+        break;
+      }
+      case "delete-comment": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          comments: thread.comments.map(
+            (comment) => comment.id === optimisticUpdate.commentId ? {
+              ...comment,
+              deletedAt: optimisticUpdate.deletedAt,
+              body: void 0
+            } : comment
+          )
+        };
+        if (!result.threads[thread.id].comments.some(
+          (comment) => comment.deletedAt === void 0
+        )) {
+          delete result.threads[thread.id];
+        }
+        break;
+      }
+      case "add-reaction": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          comments: thread.comments.map((comment) => {
+            if (comment.id === optimisticUpdate.commentId) {
+              if (comment.reactions.some(
+                (reaction) => reaction.emoji === optimisticUpdate.emoji
+              )) {
+                return {
+                  ...comment,
+                  reactions: comment.reactions.map(
+                    (reaction) => reaction.emoji === optimisticUpdate.emoji ? {
+                      ...reaction,
+                      users: [
+                        ...reaction.users,
+                        { id: optimisticUpdate.userId }
+                      ]
+                    } : reaction
+                  )
+                };
+              } else {
+                return {
+                  ...comment,
+                  reactions: [
+                    ...comment.reactions,
+                    {
+                      emoji: optimisticUpdate.emoji,
+                      createdAt: optimisticUpdate.createdAt,
+                      users: [{ id: optimisticUpdate.userId }]
+                    }
+                  ]
+                };
+              }
+            } else {
+              return comment;
+            }
+          })
+        };
+        break;
+      }
+      case "remove-reaction": {
+        const thread = result.threads[optimisticUpdate.threadId];
+        if (thread === void 0) {
+          break;
+        }
+        result.threads[thread.id] = {
+          ...thread,
+          comments: thread.comments.map((comment) => {
+            if (comment.id !== optimisticUpdate.commentId) {
+              return comment;
+            }
+            const reactionIndex = comment.reactions.findIndex(
+              (reaction) => reaction.emoji === optimisticUpdate.emoji
+            );
+            let reactions = comment.reactions;
+            if (reactionIndex >= 0 && comment.reactions[reactionIndex].users.some(
+              (user) => user.id === optimisticUpdate.userId
+            )) {
+              if (comment.reactions[reactionIndex].users.length <= 1) {
+                reactions = [...comment.reactions];
+                reactions.splice(reactionIndex, 1);
+              } else {
+                reactions[reactionIndex] = {
+                  ...reactions[reactionIndex],
+                  users: reactions[reactionIndex].users.filter(
+                    (user) => user.id !== optimisticUpdate.userId
+                  )
+                };
+              }
+            }
+            return {
+              ...comment,
+              reactions
+            };
+          })
+        };
+        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;
+}
+
 // src/client.ts
 var MIN_THROTTLE = 16;
 var MAX_THROTTLE = 1e3;
@@ -6411,6 +6787,8 @@ 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;
+var RESOLVE_USERS_BATCH_DELAY = 50;
+var RESOLVE_ROOMS_INFO_BATCH_DELAY = 50;
 function getBaseUrlFromClientOptions(clientOptions) {
   if ("liveblocksServer" in clientOptions) {
     throw new Error("Client option no longer supported");
@@ -6421,6 +6799,13 @@ function getBaseUrlFromClientOptions(clientOptions) {
     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(clientOptions.throttle ?? DEFAULT_THROTTLE);
@@ -6430,6 +6815,7 @@ function createClient(options) {
   const backgroundKeepAliveTimeout = getBackgroundKeepAliveTimeout(
     clientOptions.backgroundKeepAliveTimeout
   );
+  const baseUrl = getBaseUrlFromClientOptions(clientOptions);
   const authManager = createAuthManager(options);
   const roomsById = /* @__PURE__ */ new Map();
   function teardownRoom(room) {
@@ -6465,7 +6851,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: options2.initialPresence ?? {},
@@ -6521,58 +6906,450 @@ function createClient(options) {
     const room = roomsById.get(roomId)?.room;
     return room ? room : null;
   }
-  function forceLeave(roomId) {
-    const unsubs = roomsById.get(roomId)?.unsubs ?? /* @__PURE__ */ new Set();
-    for (const unsub of unsubs) {
-      unsub();
+  function forceLeave(roomId) {
+    const unsubs = roomsById.get(roomId)?.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
+  } = createInboxNotificationsApi({
+    baseUrl,
+    fetcher: clientOptions.polyfills?.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 resolveUsers?.({ userIds });
+      warnIfNoResolveUsers();
+      return 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 resolveRoomsInfo?.({ roomIds });
+      warnIfNoResolveRoomsInfo();
+      return roomsInfo ?? roomIds.map(() => void 0);
+    },
+    { delay: RESOLVE_ROOMS_INFO_BATCH_DELAY }
+  );
+  return Object.defineProperty(
+    {
+      logout,
+      // Old, deprecated APIs
+      enter,
+      getRoom,
+      leave: forceLeave,
+      // New, preferred API
+      enterRoom,
+      // Notifications API
+      getInboxNotifications,
+      getUnreadInboxNotificationsCount,
+      markAllInboxNotificationsAsRead,
+      markInboxNotificationAsRead,
+      // Internal
+      [kInternal]: {
+        currentUserIdStore,
+        resolveMentionSuggestions: clientOptions.resolveMentionSuggestions,
+        cacheStore,
+        usersStore,
+        roomsInfoStore
+      }
+    },
+    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 ${recommendedMin ?? min} and ${max}.` : `${option} should be at least ${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 || !body?.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)) {
+        visitor?.(block);
+      }
+    }
+    if (type === "all" || type === "inline") {
+      for (const inline of block.children) {
+        if (guard(inline)) {
+          visitor?.(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 = users?.[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 `@${user?.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>@${user?.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`@${user?.name ?? element.id}`;
   }
-  return {
-    logout,
-    // Old, deprecated APIs
-    enter,
-    getRoom,
-    leave: forceLeave,
-    // New, preferred API
-    enterRoom
+};
+async function stringifyCommentBody(body, options) {
+  const format = options?.format ?? "plain";
+  const separator = options?.separator ?? (format === "markdown" ? "\n\n" : "\n");
+  const elements = {
+    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
+    ...options?.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 ${recommendedMin ?? min} and ${max}.` : `${option} should be at least ${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,
+    options?.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: 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
@@ -6906,161 +7683,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 = options?.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 cache.get(key)?.getState();
-  }
-  function revalidate(key) {
-    return create(key).revalidate();
-  }
-  function subscribe(key, callback) {
-    return create(key).subscribe(callback) ?? noop;
-  }
-  function subscribeOnce(key, callback) {
-    return 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 = {
@@ -7150,19 +7772,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
@@ -7174,10 +7820,12 @@ export {
   LiveList,
   LiveMap,
   LiveObject,
+  NotificationsApiError,
   OpCode,
   ServerMsgCode,
   WebsocketCloseCodes,
   ackOp,
+  applyOptimisticUpdates,
   asPos,
   assert,
   assertNever,
@@ -7187,9 +7835,7 @@ export {
   convertToCommentData,
   convertToCommentUserReaction,
   convertToThreadData,
-  createAsyncCache,
   createClient,
-  createCommentsApi,
   deprecate,
   deprecateIf,
   detectDupes,
@@ -7203,6 +7849,7 @@ export {
   isLiveNode,
   isPlainObject,
   isRootCrdt,
+  kInternal,
   legacy_patchImmutableObject,
   lsonToJson,
   makeEventSource,