@liveblocks/core 1.8.2 → 1.9.0-example1

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.8.2";
+var PKG_VERSION = "1.9.0-example1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -1744,1405 +1744,1765 @@ function errorIf(condition, message) {
   }
 }
 
-// src/comments/index.ts
-function getAuthBearerHeaderFromAuthValue(authValue) {
-  if (authValue.type === "public") {
-    return authValue.publicApiKey;
-  } else {
-    return authValue.token.raw;
-  }
+// src/comments/comment-body.ts
+function isCommentBodyParagraph(element) {
+  return "type" in element && element.type === "mention";
 }
-var CommentsApiError = class extends Error {
-  constructor(message, status, details) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.details = details;
-  }
+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
 };
-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;
+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);
       }
     }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = {};
-    }
-    return body;
-  }
-  async function fetchApi(roomId2, endpoint, options) {
-    const authValue = await getAuthValue();
-    const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(roomId2)}${endpoint}`,
-      config.baseUrl
-    ).toString();
-    return await fetch(url, {
-      ...options,
-      headers: {
-        ...options?.headers,
-        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
+    if (type === "all" || type === "inline") {
+      for (const inline of block.children) {
+        if (guard(inline)) {
+          visitor?.(inline);
+        }
       }
-    });
-  }
-  async function getThreads() {
-    const response = await fetchApi(roomId, "/threads");
-    if (response.ok) {
-      const json = await response.json();
-      return json.data;
-    } else if (response.status === 404) {
-      return [];
-    } else {
-      throw new Error("There was an error while getting threads.");
     }
   }
-  function createThread({
-    metadata,
+}
+function getMentionedIdsFromCommentBody(body) {
+  const mentionedIds = /* @__PURE__ */ new Set();
+  traverseCommentBody(
     body,
-    commentId,
-    threadId
-  }) {
-    return fetchJson("/threads", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        id: threadId,
-        comment: {
-          id: commentId,
-          body
-        },
-        metadata
-      })
-    });
-  }
-  function editThreadMetadata({
-    metadata,
-    threadId
-  }) {
-    return fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
-    );
+    "mention",
+    (mention) => mentionedIds.add(mention.id)
+  );
+  return Array.from(mentionedIds);
+}
+async function resolveUsersInCommentBody(body, resolveUsers) {
+  const resolvedUsers = /* @__PURE__ */ new Map();
+  if (!resolveUsers) {
+    return resolvedUsers;
   }
-  function createComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    return fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: commentId,
-          body
-        })
-      }
-    );
+  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);
+    }
   }
-  function editComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    return fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          body
-        })
-      }
-    );
+  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 deleteComment({
-    threadId,
-    commentId
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "DELETE"
-      }
-    );
+  return new HtmlSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeHtml(value) {
+  if (value instanceof HtmlSafeString) {
+    return value.toString();
   }
-  function addReaction({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    return fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ emoji })
-      }
-    );
+  if (Array.isArray(value)) {
+    return joinHtml(value).toString();
   }
-  function removeReaction({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    return fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions/${encodeURIComponent(emoji)}`,
-      {
-        method: "DELETE"
-      }
-    );
+  return String(value).replace(
+    htmlEscapablesRegex,
+    (character) => htmlEscapables[character]
+  );
+}
+var HtmlSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
   }
-  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}`);
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeHtml(nn(this._values[i - 1])) + str;
+    });
   }
-  return String.fromCharCode(code);
+};
+function html(strings, ...values) {
+  return new HtmlSafeString(strings, values);
 }
-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;
+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 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 escapeMarkdown(value) {
+  if (value instanceof MarkdownSafeString) {
+    return value.toString();
   }
-  return ONE;
-}
-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);
+  if (Array.isArray(value)) {
+    return joinMarkdown(value).toString();
   }
-  return pos + ONE;
+  return String(value).replace(
+    markdownEscapablesRegex,
+    (character) => markdownEscapables[character]
+  );
 }
-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 MarkdownSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
   }
-}
-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);
-    }
+  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 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;
+function toAbsoluteUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  } else if (url.startsWith("www.")) {
+    return "https://" + url;
   }
-  const lastIdx = str.length - 1;
-  const last = str.charCodeAt(lastIdx);
-  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
-    return false;
+  return;
+}
+var stringifyCommentBodyPlainElements = {
+  paragraph: ({ children }) => children,
+  text: ({ element }) => element.text,
+  link: ({ element }) => element.url,
+  mention: ({ element, user }) => {
+    return `@${user?.name ?? element.id}`;
   }
-  for (let i = 0; i < lastIdx; i++) {
-    const code = str.charCodeAt(i);
-    if (code < MIN_CODE || code > MAX_CODE) {
-      return false;
+};
+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>`;
   }
-  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--;
+};
+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}\``;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return markdown`[${element.url}](${href})`;
+  },
+  mention: ({ element, user }) => {
+    return markdown`@${user?.name ?? element.id}`;
   }
-  return codes.length > 0 ? String.fromCharCode(...codes) : (
-    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
-    ONE
+};
+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);
 }
-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 isAckOp(op) {
-  return op.type === 5 /* DELETE_CRDT */ && op.id === "ACK";
-}
-
-// src/crdts/AbstractCrdt.ts
-function crdtAsLiveNode(value) {
-  return value;
+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 HasParent(node, key, pos = asPos(key)) {
-  return Object.freeze({ type: "HasParent", node, key, pos });
+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
+  };
 }
-var NoParent = Object.freeze({ type: "NoParent" });
-function Orphaned(oldKey, oldPos = asPos(oldKey)) {
-  return Object.freeze({ type: "Orphaned", oldKey, oldPos });
+function convertToCommentUserReaction(data) {
+  return {
+    ...data,
+    createdAt: new Date(data.createdAt)
+  };
 }
-var AbstractCrdt = class {
-  constructor() {
-    /** @internal */
-    this._parent = NoParent;
-  }
-  /** @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");
-    }
-  }
-  /** @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");
-    }
-  }
-  /** @internal */
-  get _pool() {
-    return this.__pool;
-  }
-  get roomId() {
-    return this.__pool ? this.__pool.roomId : null;
-  }
-  /** @internal */
-  get _id() {
-    return this.__id;
-  }
-  /** @internal */
-  get parent() {
-    return this._parent;
+
+// src/comments/index.ts
+function getAuthBearerHeaderFromAuthValue(authValue) {
+  if (authValue.type === "public") {
+    return authValue.publicApiKey;
+  } else {
+    return authValue.token.raw;
   }
-  /** @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");
-    }
+}
+var CommentsApiError = class extends Error {
+  constructor(message, status, details) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.details = details;
   }
-  /** @internal */
-  _apply(op, _isLocal) {
-    switch (op.type) {
-      case 5 /* DELETE_CRDT */: {
-        if (this.parent.type === "HasParent") {
-          return this.parent.node._detachChild(crdtAsLiveNode(this));
+};
+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);
         }
-        return { modified: false };
+        throw error3;
       }
     }
-    return { modified: false };
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
   }
-  /** @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;
+  async function fetchApi(roomId2, endpoint, options) {
+    const authValue = await getAuthValue();
+    const url = new URL(
+      `/v2/c/rooms/${encodeURIComponent(roomId2)}${endpoint}`,
+      config.baseUrl
+    ).toString();
+    return await fetch(url, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
       }
-      default:
-        return assertNever(this.parent, "Unknown state");
-    }
+    });
   }
-  /** @internal */
-  _attach(id, pool) {
-    if (this.__id || this.__pool) {
-      throw new Error("Cannot attach node: already attached");
+  async function getThreads() {
+    const response = await fetchApi(roomId, "/threads");
+    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.");
     }
-    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;
+  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
+        })
       }
-      default:
-        assertNever(this.parent, "Unknown state");
-    }
-    this.__pool = void 0;
+    );
+    return convertToThreadData(thread);
   }
-  /**
-   * @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();
+  async function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return await fetchJson(
+      `/threads/${encodeURIComponent(threadId)}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(metadata)
       }
-    }
+    );
   }
-  /**
-   * @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;
+  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);
   }
-  /**
-   * Return an immutable snapshot of this Live node and its children.
-   */
-  toImmutable() {
-    if (this._cachedImmutable === void 0) {
-      this._cachedImmutable = this._toImmutable();
-    }
-    return this._cachedImmutable;
+  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);
   }
-};
-
-// 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("");
+  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,
+    createThread,
+    editThreadMetadata,
+    createComment,
+    editComment,
+    deleteComment,
+    addReaction,
+    removeReaction
+  };
 }
 
-// src/crdts/LiveRegister.ts
-var LiveRegister = class _LiveRegister extends AbstractCrdt {
-  constructor(data) {
-    super();
-    this._data = data;
-  }
-  get data() {
-    return this._data;
+// 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}`);
   }
-  /** @internal */
-  static _deserialize([id, item], _parentToChildren, pool) {
-    const register = new _LiveRegister(item.data);
-    register._attach(id, pool);
-    return register;
+  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;
   }
-  /** @internal */
-  _toOps(parentId, parentKey, pool) {
-    if (this._id === void 0) {
-      throw new Error(
-        "Cannot serialize register if parentId or parentKey is undefined"
-      );
+}
+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;
     }
-    return [
-      {
-        type: 8 /* CREATE_REGISTER */,
-        opId: pool?.generateOpId(),
-        id: this._id,
-        parentId,
-        parentKey,
-        data: this.data
+    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);
       }
-    ];
-  }
-  /** @internal */
-  _serialize() {
-    if (this.parent.type !== "HasParent") {
-      throw new Error("Cannot serialize LiveRegister if parent is missing");
+    } else {
+      return pos.substring(0, i + 1);
     }
-    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.");
+  return ONE;
+}
+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);
   }
-  /** @internal */
-  _detachChild(_crdt) {
-    throw new Error("Method not implemented.");
+  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");
   }
-  /** @internal */
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
+}
+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);
+    }
   }
-  /** @internal */
-  _toTreeNode(key) {
-    return {
-      type: "Json",
-      id: this._id ?? nanoid(),
-      key,
-      payload: this._data
-    };
+}
+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;
   }
-  /** @internal */
-  _toImmutable() {
-    return this._data;
+  const lastIdx = str.length - 1;
+  const last = str.charCodeAt(lastIdx);
+  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
+    return false;
   }
-  clone() {
-    return deepClone(this.data);
+  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);
+}
 
-// src/crdts/LiveList.ts
-function compareNodePosition(itemA, itemB) {
-  const posA = itemA._parentPos;
-  const posB = itemB._parentPos;
-  return posA === posB ? 0 : posA < posB ? -1 : 1;
+// 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 isAckOp(op) {
+  return op.type === 5 /* DELETE_CRDT */ && op.id === "ACK";
 }
-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;
-    }
+
+// 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;
   }
   /** @internal */
-  static _deserialize([id], parentToChildren, pool) {
-    const list = new _LiveList();
-    list._attach(id, pool);
-    const children = parentToChildren.get(id);
-    if (children === void 0) {
-      return list;
-    }
-    for (const [id2, crdt] of children) {
-      const child = deserialize([id2, crdt], parentToChildren, pool);
-      child._setParentLink(list, crdt.parentKey);
-      list._insertAndSort(child);
+  _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");
     }
-    return list;
   }
-  /**
-   * @internal
-   * This function assumes that the resulting ops will be sent to the server if they have an 'opId'
-   * so we mutate _unacknowledgedSets to avoid potential flickering
-   * https://github.com/liveblocks/liveblocks/pull/1177
-   *
-   * This is quite unintuitive and should disappear as soon as
-   * we introduce an explicit LiveList.Set operation
-   */
-  _toOps(parentId, parentKey, pool) {
-    if (this._id === void 0) {
-      throw new Error("Cannot serialize item is not attached");
-    }
-    const ops = [];
-    const op = {
-      id: this._id,
-      opId: pool?.generateOpId(),
-      type: 2 /* CREATE_LIST */,
-      parentId,
-      parentKey
-    };
-    ops.push(op);
-    for (const item of this._items) {
-      const parentKey2 = item._getParentKeyOrThrow();
-      const childOps = HACK_addIntentAndDeletedIdToOperation(
-        item._toOps(this._id, parentKey2, pool),
-        void 0
-      );
-      const childOpId = childOps[0].opId;
-      if (childOpId !== void 0) {
-        this._unacknowledgedSets.set(parentKey2, childOpId);
-      }
-      ops.push(...childOps);
+  /** @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 ops;
   }
-  /**
-   * @internal
-   *
-   * Adds a new item into the sorted list, in the correct position.
-   */
-  _insertAndSort(item) {
-    this._items.push(item);
-    this._sortItems();
+  /** @internal */
+  get _pool() {
+    return this.__pool;
+  }
+  get roomId() {
+    return this.__pool ? this.__pool.roomId : null;
   }
   /** @internal */
-  _sortItems() {
-    this._items.sort(compareNodePosition);
-    this.invalidate();
+  get _id() {
+    return this.__id;
   }
   /** @internal */
-  _indexOfPosition(position) {
-    return this._items.findIndex(
-      (item) => item._getParentKeyOrThrow() === position
-    );
+  get parent() {
+    return this._parent;
   }
   /** @internal */
-  _attach(id, pool) {
-    super._attach(id, pool);
-    for (const item of this._items) {
-      item._attach(pool.generateId(), pool);
+  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");
     }
   }
   /** @internal */
-  _detach() {
-    super._detach();
-    for (const item of this._items) {
-      item._detach();
+  _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 };
   }
   /** @internal */
-  _applySetRemote(op) {
-    if (this._pool === void 0) {
-      throw new Error("Can't attach child if managed pool is not present");
-    }
-    const { id, parentKey: key } = op;
-    const child = creationOpToLiveNode(op);
-    child._attach(id, this._pool);
-    child._setParentLink(this, key);
-    const deletedId = op.deletedId;
-    const indexOfItemWithSamePosition = this._indexOfPosition(key);
-    if (indexOfItemWithSamePosition !== -1) {
-      const itemWithSamePosition = this._items[indexOfItemWithSamePosition];
-      if (itemWithSamePosition._id === deletedId) {
-        itemWithSamePosition._detach();
-        this._items[indexOfItemWithSamePosition] = child;
-        return {
-          modified: makeUpdate(this, [
-            setDelta(indexOfItemWithSamePosition, child)
-          ]),
-          reverse: []
-        };
-      } else {
-        this._implicitlyDeletedItems.add(itemWithSamePosition);
-        this._items[indexOfItemWithSamePosition] = child;
-        const delta = [
-          setDelta(indexOfItemWithSamePosition, child)
-        ];
-        const deleteDelta2 = this._detachItemAssociatedToSetOperation(
-          op.deletedId
-        );
-        if (deleteDelta2) {
-          delta.push(deleteDelta2);
+  _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;
         }
-        return {
-          modified: makeUpdate(this, delta),
-          reverse: []
-        };
-      }
-    } else {
-      const updates = [];
-      const deleteDelta2 = this._detachItemAssociatedToSetOperation(
-        op.deletedId
-      );
-      if (deleteDelta2) {
-        updates.push(deleteDelta2);
+      case "Orphaned":
+      case "NoParent": {
+        this._parent = HasParent(newParentNode, newParentKey);
+        return;
       }
-      this._insertAndSort(child);
-      updates.push(insertDelta(this._indexOfPosition(key), child));
-      return {
-        reverse: [],
-        modified: makeUpdate(this, updates)
-      };
+      default:
+        return assertNever(this.parent, "Unknown state");
     }
   }
   /** @internal */
-  _applySetAck(op) {
-    if (this._pool === void 0) {
-      throw new Error("Can't attach child if managed pool is not present");
-    }
-    const delta = [];
-    const deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-    if (deletedDelta) {
-      delta.push(deletedDelta);
+  _attach(id, pool) {
+    if (this.__id || this.__pool) {
+      throw new Error("Cannot attach node: already attached");
     }
-    const unacknowledgedOpId = this._unacknowledgedSets.get(op.parentKey);
-    if (unacknowledgedOpId !== void 0) {
-      if (unacknowledgedOpId !== op.opId) {
-        return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
-      } else {
-        this._unacknowledgedSets.delete(op.parentKey);
-      }
+    pool.addNode(id, crdtAsLiveNode(this));
+    this.__id = id;
+    this.__pool = pool;
+  }
+  /** @internal */
+  _detach() {
+    if (this.__pool && this.__id) {
+      this.__pool.deleteNode(this.__id);
     }
-    const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
-    const existingItem = this._items.find((item) => item._id === op.id);
-    if (existingItem !== void 0) {
-      if (existingItem._parentKey === op.parentKey) {
-        return {
-          modified: delta.length > 0 ? makeUpdate(this, delta) : false,
-          reverse: []
-        };
-      }
-      if (indexOfItemWithSamePosition !== -1) {
-        this._implicitlyDeletedItems.add(
-          this._items[indexOfItemWithSamePosition]
-        );
-        this._items.splice(indexOfItemWithSamePosition, 1);
-        delta.push(deleteDelta(indexOfItemWithSamePosition));
+    switch (this.parent.type) {
+      case "HasParent": {
+        this._parent = Orphaned(this.parent.key, this.parent.pos);
+        break;
       }
-      const previousIndex = this._items.indexOf(existingItem);
-      existingItem._setParentLink(this, op.parentKey);
-      this._sortItems();
-      const newIndex = this._items.indexOf(existingItem);
-      if (newIndex !== previousIndex) {
-        delta.push(moveDelta(previousIndex, newIndex, existingItem));
+      case "NoParent": {
+        this._parent = NoParent;
+        break;
       }
-      return {
-        modified: delta.length > 0 ? makeUpdate(this, delta) : false,
-        reverse: []
-      };
-    } else {
-      const orphan = this._pool.getNode(op.id);
-      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
-        orphan._setParentLink(this, op.parentKey);
-        this._implicitlyDeletedItems.delete(orphan);
-        this._insertAndSort(orphan);
-        const recreatedItemIndex = this._items.indexOf(orphan);
-        return {
-          modified: makeUpdate(this, [
-            // If there is an item at this position, update is a set, else it's an insert
-            indexOfItemWithSamePosition === -1 ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan),
-            ...delta
-          ]),
-          reverse: []
-        };
-      } else {
-        if (indexOfItemWithSamePosition !== -1) {
-          this._items.splice(indexOfItemWithSamePosition, 1);
-        }
-        const { newItem, newIndex } = this._createAttachItemAndSort(
-          op,
-          op.parentKey
-        );
-        return {
-          modified: makeUpdate(this, [
-            // If there is an item at this position, update is a set, else it's an insert
-            indexOfItemWithSamePosition === -1 ? insertDelta(newIndex, newItem) : setDelta(newIndex, newItem),
-            ...delta
-          ]),
-          reverse: []
-        };
+      case "Orphaned": {
+        break;
       }
+      default:
+        assertNever(this.parent, "Unknown state");
     }
+    this.__pool = void 0;
   }
   /**
-   * Returns the update delta of the deletion or null
    * @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.
    */
-  _detachItemAssociatedToSetOperation(deletedId) {
-    if (deletedId === void 0 || this._pool === void 0) {
-      return null;
+  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();
+      }
     }
-    const deletedItem = this._pool.getNode(deletedId);
-    if (deletedItem === void 0) {
-      return null;
+  }
+  /**
+   * @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);
     }
-    const result = this._detachChild(deletedItem);
-    if (result.modified === false) {
-      return null;
+    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 result.modified.updates[0];
+    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 */
-  _applyRemoteInsert(op) {
-    if (this._pool === void 0) {
-      throw new Error("Can't attach child if managed pool is not present");
-    }
-    const key = asPos(op.parentKey);
-    const existingItemIndex = this._indexOfPosition(key);
-    if (existingItemIndex !== -1) {
-      this._shiftItemPosition(existingItemIndex, key);
-    }
-    const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
-    return {
-      modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
-      reverse: []
-    };
+  static _deserialize([id, item], _parentToChildren, pool) {
+    const register = new _LiveRegister(item.data);
+    register._attach(id, pool);
+    return register;
   }
   /** @internal */
-  _applyInsertAck(op) {
-    const existingItem = this._items.find((item) => item._id === op.id);
-    const key = asPos(op.parentKey);
-    const itemIndexAtPosition = this._indexOfPosition(key);
-    if (existingItem) {
-      if (existingItem._parentKey === key) {
-        return {
-          modified: false
-        };
-      } else {
-        const oldPositionIndex = this._items.indexOf(existingItem);
-        if (itemIndexAtPosition !== -1) {
-          this._shiftItemPosition(itemIndexAtPosition, key);
-        }
-        existingItem._setParentLink(this, key);
-        this._sortItems();
-        const newIndex = this._indexOfPosition(key);
-        if (newIndex === oldPositionIndex) {
-          return { modified: false };
-        }
-        return {
-          modified: makeUpdate(this, [
-            moveDelta(oldPositionIndex, newIndex, existingItem)
-          ]),
-          reverse: []
-        };
-      }
-    } else {
-      const orphan = nn(this._pool).getNode(op.id);
-      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
-        orphan._setParentLink(this, key);
-        this._implicitlyDeletedItems.delete(orphan);
-        this._insertAndSort(orphan);
-        const newIndex = this._indexOfPosition(key);
-        return {
-          modified: makeUpdate(this, [insertDelta(newIndex, orphan)]),
-          reverse: []
-        };
-      } else {
-        if (itemIndexAtPosition !== -1) {
-          this._shiftItemPosition(itemIndexAtPosition, key);
-        }
-        const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
-        return {
-          modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
-          reverse: []
-        };
-      }
+  _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 */
-  _applyInsertUndoRedo(op) {
-    const { id, parentKey: key } = op;
-    const child = creationOpToLiveNode(op);
-    if (this._pool?.getNode(id) !== void 0) {
-      return { modified: false };
-    }
-    child._attach(id, nn(this._pool));
-    child._setParentLink(this, key);
-    const existingItemIndex = this._indexOfPosition(key);
-    let newKey = key;
-    if (existingItemIndex !== -1) {
-      const before2 = this._items[existingItemIndex]?._parentPos;
-      const after2 = this._items[existingItemIndex + 1]?._parentPos;
-      newKey = makePosition(before2, after2);
-      child._setParentLink(this, newKey);
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveRegister if parent is missing");
     }
-    this._insertAndSort(child);
-    const newIndex = this._indexOfPosition(newKey);
     return {
-      modified: makeUpdate(this, [insertDelta(newIndex, child)]),
-      reverse: [{ type: 5 /* DELETE_CRDT */, id }]
+      type: 3 /* REGISTER */,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key,
+      data: this.data
     };
   }
   /** @internal */
-  _applySetUndoRedo(op) {
-    const { id, parentKey: key } = op;
-    const child = creationOpToLiveNode(op);
-    if (this._pool?.getNode(id) !== void 0) {
-      return { modified: false };
-    }
-    this._unacknowledgedSets.set(key, nn(op.opId));
-    const indexOfItemWithSameKey = this._indexOfPosition(key);
-    child._attach(id, nn(this._pool));
-    child._setParentLink(this, key);
-    const newKey = key;
-    if (indexOfItemWithSameKey !== -1) {
-      const existingItem = this._items[indexOfItemWithSameKey];
-      existingItem._detach();
-      this._items[indexOfItemWithSameKey] = child;
-      const reverse = HACK_addIntentAndDeletedIdToOperation(
-        existingItem._toOps(nn(this._id), key, this._pool),
-        op.id
-      );
-      const delta = [setDelta(indexOfItemWithSameKey, child)];
-      const deletedDelta = this._detachItemAssociatedToSetOperation(
-        op.deletedId
-      );
-      if (deletedDelta) {
-        delta.push(deletedDelta);
-      }
-      return {
-        modified: makeUpdate(this, delta),
-        reverse
-      };
-    } else {
-      this._insertAndSort(child);
-      this._detachItemAssociatedToSetOperation(op.deletedId);
-      const newIndex = this._indexOfPosition(newKey);
-      return {
-        reverse: [{ type: 5 /* DELETE_CRDT */, id }],
-        modified: makeUpdate(this, [insertDelta(newIndex, child)])
-      };
-    }
+  _attachChild(_op) {
+    throw new Error("Method not implemented.");
   }
   /** @internal */
-  _attachChild(op, source) {
-    if (this._pool === void 0) {
-      throw new Error("Can't attach child if managed pool is not present");
-    }
-    let result;
-    if (op.intent === "set") {
-      if (source === 1 /* REMOTE */) {
-        result = this._applySetRemote(op);
-      } else if (source === 2 /* ACK */) {
-        result = this._applySetAck(op);
-      } else {
-        result = this._applySetUndoRedo(op);
-      }
-    } else {
-      if (source === 1 /* REMOTE */) {
-        result = this._applyRemoteInsert(op);
-      } else if (source === 2 /* ACK */) {
-        result = this._applyInsertAck(op);
-      } else {
-        result = this._applyInsertUndoRedo(op);
-      }
-    }
-    if (result.modified !== false) {
-      this.invalidate();
-    }
-    return result;
+  _detachChild(_crdt) {
+    throw new Error("Method not implemented.");
   }
   /** @internal */
-  _detachChild(child) {
-    if (child) {
-      const parentKey = nn(child._parentKey);
-      const reverse = child._toOps(nn(this._id), parentKey, this._pool);
-      const indexToDelete = this._items.indexOf(child);
-      if (indexToDelete === -1) {
-        return {
-          modified: false
-        };
-      }
-      this._items.splice(indexToDelete, 1);
-      this.invalidate();
-      child._detach();
-      return {
-        modified: makeUpdate(this, [deleteDelta(indexToDelete)]),
-        reverse
-      };
-    }
-    return { modified: false };
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
   }
   /** @internal */
-  _applySetChildKeyRemote(newKey, child) {
-    if (this._implicitlyDeletedItems.has(child)) {
-      this._implicitlyDeletedItems.delete(child);
-      child._setParentLink(this, newKey);
-      this._insertAndSort(child);
-      const newIndex = this._items.indexOf(child);
-      return {
-        modified: makeUpdate(this, [insertDelta(newIndex, child)]),
-        reverse: []
-      };
-    }
-    const previousKey = child._parentKey;
-    if (newKey === previousKey) {
-      return {
-        modified: false
-      };
-    }
-    const existingItemIndex = this._indexOfPosition(newKey);
-    if (existingItemIndex === -1) {
-      const previousIndex = this._items.indexOf(child);
-      child._setParentLink(this, newKey);
-      this._sortItems();
-      const newIndex = this._items.indexOf(child);
-      if (newIndex === previousIndex) {
-        return {
-          modified: false
-        };
-      }
-      return {
-        modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
-        reverse: []
-      };
-    } else {
-      this._items[existingItemIndex]._setParentLink(
-        this,
-        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
-      );
-      const previousIndex = this._items.indexOf(child);
-      child._setParentLink(this, newKey);
-      this._sortItems();
-      const newIndex = this._items.indexOf(child);
-      if (newIndex === previousIndex) {
-        return {
-          modified: false
-        };
-      }
-      return {
-        modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
-        reverse: []
-      };
+  _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;
     }
   }
   /** @internal */
-  _applySetChildKeyAck(newKey, child) {
-    const previousKey = nn(child._parentKey);
-    if (this._implicitlyDeletedItems.has(child)) {
-      const existingItemIndex = this._indexOfPosition(newKey);
-      this._implicitlyDeletedItems.delete(child);
-      if (existingItemIndex !== -1) {
-        this._items[existingItemIndex]._setParentLink(
-          this,
-          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+  static _deserialize([id], parentToChildren, pool) {
+    const list = new _LiveList();
+    list._attach(id, pool);
+    const children = parentToChildren.get(id);
+    if (children === void 0) {
+      return list;
+    }
+    for (const [id2, crdt] of children) {
+      const child = deserialize([id2, crdt], parentToChildren, pool);
+      child._setParentLink(list, crdt.parentKey);
+      list._insertAndSort(child);
+    }
+    return list;
+  }
+  /**
+   * @internal
+   * This function assumes that the resulting ops will be sent to the server if they have an 'opId'
+   * so we mutate _unacknowledgedSets to avoid potential flickering
+   * https://github.com/liveblocks/liveblocks/pull/1177
+   *
+   * This is quite unintuitive and should disappear as soon as
+   * we introduce an explicit LiveList.Set operation
+   */
+  _toOps(parentId, parentKey, pool) {
+    if (this._id === void 0) {
+      throw new Error("Cannot serialize item is not attached");
+    }
+    const ops = [];
+    const op = {
+      id: this._id,
+      opId: pool?.generateOpId(),
+      type: 2 /* CREATE_LIST */,
+      parentId,
+      parentKey
+    };
+    ops.push(op);
+    for (const item of this._items) {
+      const parentKey2 = item._getParentKeyOrThrow();
+      const childOps = HACK_addIntentAndDeletedIdToOperation(
+        item._toOps(this._id, parentKey2, pool),
+        void 0
+      );
+      const childOpId = childOps[0].opId;
+      if (childOpId !== void 0) {
+        this._unacknowledgedSets.set(parentKey2, childOpId);
+      }
+      ops.push(...childOps);
+    }
+    return ops;
+  }
+  /**
+   * @internal
+   *
+   * Adds a new item into the sorted list, in the correct position.
+   */
+  _insertAndSort(item) {
+    this._items.push(item);
+    this._sortItems();
+  }
+  /** @internal */
+  _sortItems() {
+    this._items.sort(compareNodePosition);
+    this.invalidate();
+  }
+  /** @internal */
+  _indexOfPosition(position) {
+    return this._items.findIndex(
+      (item) => item._getParentKeyOrThrow() === position
+    );
+  }
+  /** @internal */
+  _attach(id, pool) {
+    super._attach(id, pool);
+    for (const item of this._items) {
+      item._attach(pool.generateId(), pool);
+    }
+  }
+  /** @internal */
+  _detach() {
+    super._detach();
+    for (const item of this._items) {
+      item._detach();
+    }
+  }
+  /** @internal */
+  _applySetRemote(op) {
+    if (this._pool === void 0) {
+      throw new Error("Can't attach child if managed pool is not present");
+    }
+    const { id, parentKey: key } = op;
+    const child = creationOpToLiveNode(op);
+    child._attach(id, this._pool);
+    child._setParentLink(this, key);
+    const deletedId = op.deletedId;
+    const indexOfItemWithSamePosition = this._indexOfPosition(key);
+    if (indexOfItemWithSamePosition !== -1) {
+      const itemWithSamePosition = this._items[indexOfItemWithSamePosition];
+      if (itemWithSamePosition._id === deletedId) {
+        itemWithSamePosition._detach();
+        this._items[indexOfItemWithSamePosition] = child;
+        return {
+          modified: makeUpdate(this, [
+            setDelta(indexOfItemWithSamePosition, child)
+          ]),
+          reverse: []
+        };
+      } else {
+        this._implicitlyDeletedItems.add(itemWithSamePosition);
+        this._items[indexOfItemWithSamePosition] = child;
+        const delta = [
+          setDelta(indexOfItemWithSamePosition, child)
+        ];
+        const deleteDelta2 = this._detachItemAssociatedToSetOperation(
+          op.deletedId
         );
+        if (deleteDelta2) {
+          delta.push(deleteDelta2);
+        }
+        return {
+          modified: makeUpdate(this, delta),
+          reverse: []
+        };
+      }
+    } else {
+      const updates = [];
+      const deleteDelta2 = this._detachItemAssociatedToSetOperation(
+        op.deletedId
+      );
+      if (deleteDelta2) {
+        updates.push(deleteDelta2);
       }
-      child._setParentLink(this, newKey);
       this._insertAndSort(child);
+      updates.push(insertDelta(this._indexOfPosition(key), child));
       return {
-        modified: false
+        reverse: [],
+        modified: makeUpdate(this, updates)
       };
-    } else {
-      if (newKey === previousKey) {
+    }
+  }
+  /** @internal */
+  _applySetAck(op) {
+    if (this._pool === void 0) {
+      throw new Error("Can't attach child if managed pool is not present");
+    }
+    const delta = [];
+    const deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+    if (deletedDelta) {
+      delta.push(deletedDelta);
+    }
+    const unacknowledgedOpId = this._unacknowledgedSets.get(op.parentKey);
+    if (unacknowledgedOpId !== void 0) {
+      if (unacknowledgedOpId !== op.opId) {
+        return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
+      } else {
+        this._unacknowledgedSets.delete(op.parentKey);
+      }
+    }
+    const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
+    const existingItem = this._items.find((item) => item._id === op.id);
+    if (existingItem !== void 0) {
+      if (existingItem._parentKey === op.parentKey) {
         return {
-          modified: false
+          modified: delta.length > 0 ? makeUpdate(this, delta) : false,
+          reverse: []
         };
       }
-      const previousIndex = this._items.indexOf(child);
-      const existingItemIndex = this._indexOfPosition(newKey);
-      if (existingItemIndex !== -1) {
-        this._items[existingItemIndex]._setParentLink(
-          this,
-          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+      if (indexOfItemWithSamePosition !== -1) {
+        this._implicitlyDeletedItems.add(
+          this._items[indexOfItemWithSamePosition]
         );
+        this._items.splice(indexOfItemWithSamePosition, 1);
+        delta.push(deleteDelta(indexOfItemWithSamePosition));
       }
-      child._setParentLink(this, newKey);
+      const previousIndex = this._items.indexOf(existingItem);
+      existingItem._setParentLink(this, op.parentKey);
       this._sortItems();
-      const newIndex = this._items.indexOf(child);
-      if (previousIndex === newIndex) {
+      const newIndex = this._items.indexOf(existingItem);
+      if (newIndex !== previousIndex) {
+        delta.push(moveDelta(previousIndex, newIndex, existingItem));
+      }
+      return {
+        modified: delta.length > 0 ? makeUpdate(this, delta) : false,
+        reverse: []
+      };
+    } else {
+      const orphan = this._pool.getNode(op.id);
+      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+        orphan._setParentLink(this, op.parentKey);
+        this._implicitlyDeletedItems.delete(orphan);
+        this._insertAndSort(orphan);
+        const recreatedItemIndex = this._items.indexOf(orphan);
         return {
-          modified: false
+          modified: makeUpdate(this, [
+            // If there is an item at this position, update is a set, else it's an insert
+            indexOfItemWithSamePosition === -1 ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan),
+            ...delta
+          ]),
+          reverse: []
         };
       } else {
+        if (indexOfItemWithSamePosition !== -1) {
+          this._items.splice(indexOfItemWithSamePosition, 1);
+        }
+        const { newItem, newIndex } = this._createAttachItemAndSort(
+          op,
+          op.parentKey
+        );
         return {
           modified: makeUpdate(this, [
-            moveDelta(previousIndex, newIndex, child)
+            // If there is an item at this position, update is a set, else it's an insert
+            indexOfItemWithSamePosition === -1 ? insertDelta(newIndex, newItem) : setDelta(newIndex, newItem),
+            ...delta
           ]),
           reverse: []
         };
       }
     }
   }
+  /**
+   * Returns the update delta of the deletion or null
+   * @internal
+   */
+  _detachItemAssociatedToSetOperation(deletedId) {
+    if (deletedId === void 0 || this._pool === void 0) {
+      return null;
+    }
+    const deletedItem = this._pool.getNode(deletedId);
+    if (deletedItem === void 0) {
+      return null;
+    }
+    const result = this._detachChild(deletedItem);
+    if (result.modified === false) {
+      return null;
+    }
+    return result.modified.updates[0];
+  }
   /** @internal */
-  _applySetChildKeyUndoRedo(newKey, child) {
-    const previousKey = nn(child._parentKey);
-    const previousIndex = this._items.indexOf(child);
-    const existingItemIndex = this._indexOfPosition(newKey);
+  _applyRemoteInsert(op) {
+    if (this._pool === void 0) {
+      throw new Error("Can't attach child if managed pool is not present");
+    }
+    const key = asPos(op.parentKey);
+    const existingItemIndex = this._indexOfPosition(key);
     if (existingItemIndex !== -1) {
-      this._items[existingItemIndex]._setParentLink(
-        this,
-        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
-      );
-    }
-    child._setParentLink(this, newKey);
-    this._sortItems();
-    const newIndex = this._items.indexOf(child);
-    if (previousIndex === newIndex) {
-      return {
-        modified: false
-      };
+      this._shiftItemPosition(existingItemIndex, key);
     }
+    const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
     return {
-      modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
-      reverse: [
-        {
-          type: 1 /* SET_PARENT_KEY */,
-          id: nn(child._id),
-          parentKey: previousKey
-        }
-      ]
+      modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
+      reverse: []
     };
   }
   /** @internal */
-  _setChildKey(newKey, child, source) {
-    if (source === 1 /* REMOTE */) {
-      return this._applySetChildKeyRemote(newKey, child);
-    } else if (source === 2 /* ACK */) {
-      return this._applySetChildKeyAck(newKey, child);
+  _applyInsertAck(op) {
+    const existingItem = this._items.find((item) => item._id === op.id);
+    const key = asPos(op.parentKey);
+    const itemIndexAtPosition = this._indexOfPosition(key);
+    if (existingItem) {
+      if (existingItem._parentKey === key) {
+        return {
+          modified: false
+        };
+      } else {
+        const oldPositionIndex = this._items.indexOf(existingItem);
+        if (itemIndexAtPosition !== -1) {
+          this._shiftItemPosition(itemIndexAtPosition, key);
+        }
+        existingItem._setParentLink(this, key);
+        this._sortItems();
+        const newIndex = this._indexOfPosition(key);
+        if (newIndex === oldPositionIndex) {
+          return { modified: false };
+        }
+        return {
+          modified: makeUpdate(this, [
+            moveDelta(oldPositionIndex, newIndex, existingItem)
+          ]),
+          reverse: []
+        };
+      }
     } else {
-      return this._applySetChildKeyUndoRedo(newKey, child);
+      const orphan = nn(this._pool).getNode(op.id);
+      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+        orphan._setParentLink(this, key);
+        this._implicitlyDeletedItems.delete(orphan);
+        this._insertAndSort(orphan);
+        const newIndex = this._indexOfPosition(key);
+        return {
+          modified: makeUpdate(this, [insertDelta(newIndex, orphan)]),
+          reverse: []
+        };
+      } else {
+        if (itemIndexAtPosition !== -1) {
+          this._shiftItemPosition(itemIndexAtPosition, key);
+        }
+        const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
+        return {
+          modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
+          reverse: []
+        };
+      }
     }
   }
   /** @internal */
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
-  }
-  /** @internal */
-  _serialize() {
-    if (this.parent.type !== "HasParent") {
-      throw new Error("Cannot serialize LiveList if parent is missing");
+  _applyInsertUndoRedo(op) {
+    const { id, parentKey: key } = op;
+    const child = creationOpToLiveNode(op);
+    if (this._pool?.getNode(id) !== void 0) {
+      return { modified: false };
+    }
+    child._attach(id, nn(this._pool));
+    child._setParentLink(this, key);
+    const existingItemIndex = this._indexOfPosition(key);
+    let newKey = key;
+    if (existingItemIndex !== -1) {
+      const before2 = this._items[existingItemIndex]?._parentPos;
+      const after2 = this._items[existingItemIndex + 1]?._parentPos;
+      newKey = makePosition(before2, after2);
+      child._setParentLink(this, newKey);
     }
+    this._insertAndSort(child);
+    const newIndex = this._indexOfPosition(newKey);
     return {
-      type: 1 /* LIST */,
-      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-      parentKey: this.parent.key
+      modified: makeUpdate(this, [insertDelta(newIndex, child)]),
+      reverse: [{ type: 5 /* DELETE_CRDT */, id }]
     };
   }
-  /**
-   * Returns the number of elements.
-   */
-  get length() {
-    return this._items.length;
-  }
-  /**
-   * Adds one element to the end of the LiveList.
-   * @param element The element to add to the end of the LiveList.
-   */
-  push(element) {
-    this._pool?.assertStorageIsWritable();
-    return this.insert(element, this.length);
-  }
-  /**
-   * Inserts one element at a specified index.
-   * @param element The element to insert.
-   * @param index The index at which you want to insert the element.
-   */
-  insert(element, index) {
-    this._pool?.assertStorageIsWritable();
-    if (index < 0 || index > this._items.length) {
-      throw new Error(
-        `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
-      );
+  /** @internal */
+  _applySetUndoRedo(op) {
+    const { id, parentKey: key } = op;
+    const child = creationOpToLiveNode(op);
+    if (this._pool?.getNode(id) !== void 0) {
+      return { modified: false };
     }
-    const before2 = this._items[index - 1] ? this._items[index - 1]._parentPos : void 0;
-    const after2 = this._items[index] ? this._items[index]._parentPos : void 0;
-    const position = makePosition(before2, after2);
-    const value = lsonToLiveNode(element);
-    value._setParentLink(this, position);
-    this._insertAndSort(value);
-    if (this._pool && this._id) {
-      const id = this._pool.generateId();
-      value._attach(id, this._pool);
-      this._pool.dispatch(
-        value._toOps(this._id, position, this._pool),
-        [{ type: 5 /* DELETE_CRDT */, id }],
-        /* @__PURE__ */ new Map([
-          [this._id, makeUpdate(this, [insertDelta(index, value)])]
-        ])
+    this._unacknowledgedSets.set(key, nn(op.opId));
+    const indexOfItemWithSameKey = this._indexOfPosition(key);
+    child._attach(id, nn(this._pool));
+    child._setParentLink(this, key);
+    const newKey = key;
+    if (indexOfItemWithSameKey !== -1) {
+      const existingItem = this._items[indexOfItemWithSameKey];
+      existingItem._detach();
+      this._items[indexOfItemWithSameKey] = child;
+      const reverse = HACK_addIntentAndDeletedIdToOperation(
+        existingItem._toOps(nn(this._id), key, this._pool),
+        op.id
       );
-    }
-  }
-  /**
-   * Move one element from one index to another.
-   * @param index The index of the element to move
-   * @param targetIndex The index where the element should be after moving.
-   */
-  move(index, targetIndex) {
-    this._pool?.assertStorageIsWritable();
-    if (targetIndex < 0) {
-      throw new Error("targetIndex cannot be less than 0");
-    }
-    if (targetIndex >= this._items.length) {
-      throw new Error(
-        "targetIndex cannot be greater or equal than the list length"
+      const delta = [setDelta(indexOfItemWithSameKey, child)];
+      const deletedDelta = this._detachItemAssociatedToSetOperation(
+        op.deletedId
       );
+      if (deletedDelta) {
+        delta.push(deletedDelta);
+      }
+      return {
+        modified: makeUpdate(this, delta),
+        reverse
+      };
+    } else {
+      this._insertAndSort(child);
+      this._detachItemAssociatedToSetOperation(op.deletedId);
+      const newIndex = this._indexOfPosition(newKey);
+      return {
+        reverse: [{ type: 5 /* DELETE_CRDT */, id }],
+        modified: makeUpdate(this, [insertDelta(newIndex, child)])
+      };
     }
-    if (index < 0) {
-      throw new Error("index cannot be less than 0");
-    }
-    if (index >= this._items.length) {
-      throw new Error("index cannot be greater or equal than the list length");
+  }
+  /** @internal */
+  _attachChild(op, source) {
+    if (this._pool === void 0) {
+      throw new Error("Can't attach child if managed pool is not present");
     }
-    let beforePosition = null;
-    let afterPosition = null;
-    if (index < targetIndex) {
-      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._parentPos;
-      beforePosition = this._items[targetIndex]._parentPos;
+    let result;
+    if (op.intent === "set") {
+      if (source === 1 /* REMOTE */) {
+        result = this._applySetRemote(op);
+      } else if (source === 2 /* ACK */) {
+        result = this._applySetAck(op);
+      } else {
+        result = this._applySetUndoRedo(op);
+      }
     } else {
-      afterPosition = this._items[targetIndex]._parentPos;
-      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._parentPos;
+      if (source === 1 /* REMOTE */) {
+        result = this._applyRemoteInsert(op);
+      } else if (source === 2 /* ACK */) {
+        result = this._applyInsertAck(op);
+      } else {
+        result = this._applyInsertUndoRedo(op);
+      }
     }
-    const position = makePosition(beforePosition, afterPosition);
-    const item = this._items[index];
-    const previousPosition = item._getParentKeyOrThrow();
-    item._setParentLink(this, position);
-    this._sortItems();
-    if (this._pool && this._id) {
-      const storageUpdates = /* @__PURE__ */ new Map([
-        [this._id, makeUpdate(this, [moveDelta(index, targetIndex, item)])]
-      ]);
-      this._pool.dispatch(
-        [
-          {
-            type: 1 /* SET_PARENT_KEY */,
-            id: nn(item._id),
-            opId: this._pool.generateOpId(),
-            parentKey: position
-          }
-        ],
-        [
-          {
-            type: 1 /* SET_PARENT_KEY */,
-            id: nn(item._id),
-            parentKey: previousPosition
-          }
-        ],
-        storageUpdates
-      );
+    if (result.modified !== false) {
+      this.invalidate();
     }
+    return result;
   }
-  /**
-   * Deletes an element at the specified index
-   * @param index The index of the element to delete
-   */
-  delete(index) {
-    this._pool?.assertStorageIsWritable();
-    if (index < 0 || index >= this._items.length) {
-      throw new Error(
-        `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+  /** @internal */
+  _detachChild(child) {
+    if (child) {
+      const parentKey = nn(child._parentKey);
+      const reverse = child._toOps(nn(this._id), parentKey, this._pool);
+      const indexToDelete = this._items.indexOf(child);
+      if (indexToDelete === -1) {
+        return {
+          modified: false
+        };
+      }
+      this._items.splice(indexToDelete, 1);
+      this.invalidate();
+      child._detach();
+      return {
+        modified: makeUpdate(this, [deleteDelta(indexToDelete)]),
+        reverse
+      };
+    }
+    return { modified: false };
+  }
+  /** @internal */
+  _applySetChildKeyRemote(newKey, child) {
+    if (this._implicitlyDeletedItems.has(child)) {
+      this._implicitlyDeletedItems.delete(child);
+      child._setParentLink(this, newKey);
+      this._insertAndSort(child);
+      const newIndex = this._items.indexOf(child);
+      return {
+        modified: makeUpdate(this, [insertDelta(newIndex, child)]),
+        reverse: []
+      };
+    }
+    const previousKey = child._parentKey;
+    if (newKey === previousKey) {
+      return {
+        modified: false
+      };
+    }
+    const existingItemIndex = this._indexOfPosition(newKey);
+    if (existingItemIndex === -1) {
+      const previousIndex = this._items.indexOf(child);
+      child._setParentLink(this, newKey);
+      this._sortItems();
+      const newIndex = this._items.indexOf(child);
+      if (newIndex === previousIndex) {
+        return {
+          modified: false
+        };
+      }
+      return {
+        modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
+        reverse: []
+      };
+    } else {
+      this._items[existingItemIndex]._setParentLink(
+        this,
+        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
       );
+      const previousIndex = this._items.indexOf(child);
+      child._setParentLink(this, newKey);
+      this._sortItems();
+      const newIndex = this._items.indexOf(child);
+      if (newIndex === previousIndex) {
+        return {
+          modified: false
+        };
+      }
+      return {
+        modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
+        reverse: []
+      };
     }
-    const item = this._items[index];
-    item._detach();
-    this._items.splice(index, 1);
-    this.invalidate();
-    if (this._pool) {
-      const childRecordId = item._id;
-      if (childRecordId) {
-        const storageUpdates = /* @__PURE__ */ new Map();
-        storageUpdates.set(
-          nn(this._id),
-          makeUpdate(this, [deleteDelta(index)])
+  }
+  /** @internal */
+  _applySetChildKeyAck(newKey, child) {
+    const previousKey = nn(child._parentKey);
+    if (this._implicitlyDeletedItems.has(child)) {
+      const existingItemIndex = this._indexOfPosition(newKey);
+      this._implicitlyDeletedItems.delete(child);
+      if (existingItemIndex !== -1) {
+        this._items[existingItemIndex]._setParentLink(
+          this,
+          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
         );
-        this._pool.dispatch(
-          [
-            {
-              id: childRecordId,
-              opId: this._pool.generateOpId(),
-              type: 5 /* DELETE_CRDT */
-            }
-          ],
-          item._toOps(nn(this._id), item._getParentKeyOrThrow()),
-          storageUpdates
+      }
+      child._setParentLink(this, newKey);
+      this._insertAndSort(child);
+      return {
+        modified: false
+      };
+    } else {
+      if (newKey === previousKey) {
+        return {
+          modified: false
+        };
+      }
+      const previousIndex = this._items.indexOf(child);
+      const existingItemIndex = this._indexOfPosition(newKey);
+      if (existingItemIndex !== -1) {
+        this._items[existingItemIndex]._setParentLink(
+          this,
+          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
         );
       }
+      child._setParentLink(this, newKey);
+      this._sortItems();
+      const newIndex = this._items.indexOf(child);
+      if (previousIndex === newIndex) {
+        return {
+          modified: false
+        };
+      } else {
+        return {
+          modified: makeUpdate(this, [
+            moveDelta(previousIndex, newIndex, child)
+          ]),
+          reverse: []
+        };
+      }
     }
   }
-  clear() {
-    this._pool?.assertStorageIsWritable();
-    if (this._pool) {
-      const ops = [];
-      const reverseOps = [];
-      const updateDelta = [];
-      for (const item of this._items) {
-        item._detach();
-        const childId = item._id;
-        if (childId) {
-          ops.push({
-            type: 5 /* DELETE_CRDT */,
-            id: childId,
-            opId: this._pool.generateOpId()
-          });
-          reverseOps.push(
-            ...item._toOps(nn(this._id), item._getParentKeyOrThrow())
-          );
-          updateDelta.push(deleteDelta(0));
+  /** @internal */
+  _applySetChildKeyUndoRedo(newKey, child) {
+    const previousKey = nn(child._parentKey);
+    const previousIndex = this._items.indexOf(child);
+    const existingItemIndex = this._indexOfPosition(newKey);
+    if (existingItemIndex !== -1) {
+      this._items[existingItemIndex]._setParentLink(
+        this,
+        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+      );
+    }
+    child._setParentLink(this, newKey);
+    this._sortItems();
+    const newIndex = this._items.indexOf(child);
+    if (previousIndex === newIndex) {
+      return {
+        modified: false
+      };
+    }
+    return {
+      modified: makeUpdate(this, [moveDelta(previousIndex, newIndex, child)]),
+      reverse: [
+        {
+          type: 1 /* SET_PARENT_KEY */,
+          id: nn(child._id),
+          parentKey: previousKey
         }
-      }
-      this._items = [];
-      this.invalidate();
-      const storageUpdates = /* @__PURE__ */ new Map();
-      storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta));
-      this._pool.dispatch(ops, reverseOps, storageUpdates);
+      ]
+    };
+  }
+  /** @internal */
+  _setChildKey(newKey, child, source) {
+    if (source === 1 /* REMOTE */) {
+      return this._applySetChildKeyRemote(newKey, child);
+    } else if (source === 2 /* ACK */) {
+      return this._applySetChildKeyAck(newKey, child);
     } else {
-      for (const item of this._items) {
-        item._detach();
-      }
-      this._items = [];
-      this.invalidate();
+      return this._applySetChildKeyUndoRedo(newKey, child);
     }
   }
-  set(index, item) {
+  /** @internal */
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
+  }
+  /** @internal */
+  _serialize() {
+    if (this.parent.type !== "HasParent") {
+      throw new Error("Cannot serialize LiveList if parent is missing");
+    }
+    return {
+      type: 1 /* LIST */,
+      parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+      parentKey: this.parent.key
+    };
+  }
+  /**
+   * Returns the number of elements.
+   */
+  get length() {
+    return this._items.length;
+  }
+  /**
+   * Adds one element to the end of the LiveList.
+   * @param element The element to add to the end of the LiveList.
+   */
+  push(element) {
     this._pool?.assertStorageIsWritable();
-    if (index < 0 || index >= this._items.length) {
+    return this.insert(element, this.length);
+  }
+  /**
+   * Inserts one element at a specified index.
+   * @param element The element to insert.
+   * @param index The index at which you want to insert the element.
+   */
+  insert(element, index) {
+    this._pool?.assertStorageIsWritable();
+    if (index < 0 || index > this._items.length) {
       throw new Error(
-        `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+        `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
       );
     }
-    const existingItem = this._items[index];
-    const position = existingItem._getParentKeyOrThrow();
-    const existingId = existingItem._id;
-    existingItem._detach();
-    const value = lsonToLiveNode(item);
+    const before2 = this._items[index - 1] ? this._items[index - 1]._parentPos : void 0;
+    const after2 = this._items[index] ? this._items[index]._parentPos : void 0;
+    const position = makePosition(before2, after2);
+    const value = lsonToLiveNode(element);
     value._setParentLink(this, position);
-    this._items[index] = value;
-    this.invalidate();
+    this._insertAndSort(value);
+    if (this._pool && this._id) {
+      const id = this._pool.generateId();
+      value._attach(id, this._pool);
+      this._pool.dispatch(
+        value._toOps(this._id, position, this._pool),
+        [{ type: 5 /* DELETE_CRDT */, id }],
+        /* @__PURE__ */ new Map([
+          [this._id, makeUpdate(this, [insertDelta(index, value)])]
+        ])
+      );
+    }
+  }
+  /**
+   * Move one element from one index to another.
+   * @param index The index of the element to move
+   * @param targetIndex The index where the element should be after moving.
+   */
+  move(index, targetIndex) {
+    this._pool?.assertStorageIsWritable();
+    if (targetIndex < 0) {
+      throw new Error("targetIndex cannot be less than 0");
+    }
+    if (targetIndex >= this._items.length) {
+      throw new Error(
+        "targetIndex cannot be greater or equal than the list length"
+      );
+    }
+    if (index < 0) {
+      throw new Error("index cannot be less than 0");
+    }
+    if (index >= this._items.length) {
+      throw new Error("index cannot be greater or equal than the list length");
+    }
+    let beforePosition = null;
+    let afterPosition = null;
+    if (index < targetIndex) {
+      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._parentPos;
+      beforePosition = this._items[targetIndex]._parentPos;
+    } else {
+      afterPosition = this._items[targetIndex]._parentPos;
+      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._parentPos;
+    }
+    const position = makePosition(beforePosition, afterPosition);
+    const item = this._items[index];
+    const previousPosition = item._getParentKeyOrThrow();
+    item._setParentLink(this, position);
+    this._sortItems();
+    if (this._pool && this._id) {
+      const storageUpdates = /* @__PURE__ */ new Map([
+        [this._id, makeUpdate(this, [moveDelta(index, targetIndex, item)])]
+      ]);
+      this._pool.dispatch(
+        [
+          {
+            type: 1 /* SET_PARENT_KEY */,
+            id: nn(item._id),
+            opId: this._pool.generateOpId(),
+            parentKey: position
+          }
+        ],
+        [
+          {
+            type: 1 /* SET_PARENT_KEY */,
+            id: nn(item._id),
+            parentKey: previousPosition
+          }
+        ],
+        storageUpdates
+      );
+    }
+  }
+  /**
+   * Deletes an element at the specified index
+   * @param index The index of the element to delete
+   */
+  delete(index) {
+    this._pool?.assertStorageIsWritable();
+    if (index < 0 || index >= this._items.length) {
+      throw new Error(
+        `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+      );
+    }
+    const item = this._items[index];
+    item._detach();
+    this._items.splice(index, 1);
+    this.invalidate();
+    if (this._pool) {
+      const childRecordId = item._id;
+      if (childRecordId) {
+        const storageUpdates = /* @__PURE__ */ new Map();
+        storageUpdates.set(
+          nn(this._id),
+          makeUpdate(this, [deleteDelta(index)])
+        );
+        this._pool.dispatch(
+          [
+            {
+              id: childRecordId,
+              opId: this._pool.generateOpId(),
+              type: 5 /* DELETE_CRDT */
+            }
+          ],
+          item._toOps(nn(this._id), item._getParentKeyOrThrow()),
+          storageUpdates
+        );
+      }
+    }
+  }
+  clear() {
+    this._pool?.assertStorageIsWritable();
+    if (this._pool) {
+      const ops = [];
+      const reverseOps = [];
+      const updateDelta = [];
+      for (const item of this._items) {
+        item._detach();
+        const childId = item._id;
+        if (childId) {
+          ops.push({
+            type: 5 /* DELETE_CRDT */,
+            id: childId,
+            opId: this._pool.generateOpId()
+          });
+          reverseOps.push(
+            ...item._toOps(nn(this._id), item._getParentKeyOrThrow())
+          );
+          updateDelta.push(deleteDelta(0));
+        }
+      }
+      this._items = [];
+      this.invalidate();
+      const storageUpdates = /* @__PURE__ */ new Map();
+      storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta));
+      this._pool.dispatch(ops, reverseOps, storageUpdates);
+    } else {
+      for (const item of this._items) {
+        item._detach();
+      }
+      this._items = [];
+      this.invalidate();
+    }
+  }
+  set(index, item) {
+    this._pool?.assertStorageIsWritable();
+    if (index < 0 || index >= this._items.length) {
+      throw new Error(
+        `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+      );
+    }
+    const existingItem = this._items[index];
+    const position = existingItem._getParentKeyOrThrow();
+    const existingId = existingItem._id;
+    existingItem._detach();
+    const value = lsonToLiveNode(item);
+    value._setParentLink(this, position);
+    this._items[index] = value;
+    this.invalidate();
     if (this._pool && this._id) {
       const id = this._pool.generateId();
       value._attach(id, this._pool);
@@ -4995,9 +5355,13 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
-  async function httpSend(authTokenOrPublicApiKey, roomId, nonce, messages) {
+  async function httpPostToRoom(endpoint, body) {
+    if (!managedSocket.authValue) {
+      throw new Error("Not authorized");
+    }
+    const authTokenOrPublicApiKey = managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw;
     const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(roomId)}/send-message`,
+      `/v2/c/rooms/${encodeURIComponent(config.roomId)}${endpoint}`,
       config.baseUrl
     ).toString();
     const fetcher = config.polyfills?.fetch || /* istanbul ignore next */
@@ -5008,25 +5372,22 @@ function createRoom(options, config) {
         "Content-Type": "application/json",
         Authorization: `Bearer ${authTokenOrPublicApiKey}`
       },
-      body: JSON.stringify({ nonce, messages })
+      body: JSON.stringify(body)
     });
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
     const nonce = context.dynamicSessionInfo.current?.nonce;
-    if (config.unstable_fallbackToHTTP && managedSocket.authValue && nonce) {
+    if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
-        void httpSend(
-          managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw,
-          config.roomId,
-          nonce,
-          messages
-        ).then((resp) => {
-          if (!resp.ok && resp.status === 403) {
-            managedSocket.reconnect();
+        void httpPostToRoom("/send-message", { nonce, messages }).then(
+          (resp) => {
+            if (!resp.ok && resp.status === 403) {
+              managedSocket.reconnect();
+            }
           }
-        });
+        );
         warn(
           "Message was too large for websockets and sent over HTTP instead"
         );
@@ -5539,7 +5900,7 @@ ${Array.from(traces).join("\n\n")}`
     }
     const now = Date.now();
     const elapsedMillis = now - context.buffer.lastFlushedAt;
-    if (elapsedMillis > config.throttleDelay) {
+    if (elapsedMillis >= config.throttleDelay) {
       const messagesToFlush = serializeBuffer();
       if (messagesToFlush.length === 0) {
         return;
@@ -5906,1161 +6267,852 @@ function makeClassicSubscribeFn(events) {
           const cb = callback;
           return events.others.subscribe((event) => {
             const { others, ...internalEvent } = event;
-            return cb(others, internalEvent);
-          });
-        }
-        case "error":
-          return events.error.subscribe(callback);
-        case "connection": {
-          const cb = callback;
-          return events.status.subscribe(
-            (status) => cb(newToLegacyStatus(status))
-          );
-        }
-        case "status":
-          return events.status.subscribe(callback);
-        case "lost-connection":
-          return events.lostConnection.subscribe(
-            callback
-          );
-        case "history":
-          return events.history.subscribe(callback);
-        case "storage-status":
-          return events.storageStatus.subscribe(
-            callback
-          );
-        default:
-          return assertNever(
-            first,
-            `"${String(first)}" is not a valid event name`
-          );
-      }
-    }
-    if (second === void 0 || typeof first === "function") {
-      if (typeof first === "function") {
-        const storageCallback = first;
-        return events.storage.subscribe(storageCallback);
-      } else {
-        throw new Error("Please specify a listener callback");
-      }
-    }
-    if (isLiveNode(first)) {
-      const node = first;
-      if (options?.isDeep) {
-        const storageCallback = second;
-        return subscribeToLiveStructureDeeply(node, storageCallback);
-      } else {
-        const nodeCallback = second;
-        return subscribeToLiveStructureShallowly(node, nodeCallback);
-      }
-    }
-    throw new Error(
-      `${String(first)} is not a value that can be subscribed to.`
-    );
-  }
-  return subscribe;
-}
-function isRoomEventName(value) {
-  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "history" || value === "status" || value === "storage-status" || value === "lost-connection" || value === "connection";
-}
-function makeAuthDelegateForRoom(roomId, authManager) {
-  return async () => {
-    return authManager.getAuthValue("room:read", roomId);
-  };
-}
-function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
-  return (authValue) => {
-    const ws = WebSocketPolyfill ?? (typeof WebSocket === "undefined" ? void 0 : WebSocket);
-    if (ws === void 0) {
-      throw new StopRetrying(
-        "To use Liveblocks client in a non-DOM environment, you need to provide a WebSocket polyfill."
-      );
-    }
-    const url = new URL(baseUrl);
-    url.protocol = url.protocol === "http:" ? "ws" : "wss";
-    url.pathname = "/v7";
-    url.searchParams.set("roomId", roomId);
-    if (authValue.type === "secret") {
-      url.searchParams.set("tok", authValue.token.raw);
-    } else if (authValue.type === "public") {
-      url.searchParams.set("pubkey", authValue.publicApiKey);
-    } else {
-      return assertNever(authValue, "Unhandled case");
-    }
-    url.searchParams.set("version", PKG_VERSION || "dev");
-    return new ws(url.toString());
-  };
-}
-
-// src/client.ts
-var MIN_THROTTLE = 16;
-var MAX_THROTTLE = 1e3;
-var DEFAULT_THROTTLE = 100;
-var MIN_BACKGROUND_KEEP_ALIVE_TIMEOUT = 15e3;
-var MIN_LOST_CONNECTION_TIMEOUT = 200;
-var RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT = 1e3;
-var MAX_LOST_CONNECTION_TIMEOUT = 3e4;
-var DEFAULT_LOST_CONNECTION_TIMEOUT = 5e3;
-function getBaseUrlFromClientOptions(clientOptions) {
-  if ("liveblocksServer" in clientOptions) {
-    throw new Error("Client option no longer supported");
-  }
-  if (typeof clientOptions.baseUrl === "string" && clientOptions.baseUrl.startsWith("http")) {
-    return clientOptions.baseUrl;
-  } else {
-    return DEFAULT_BASE_URL;
-  }
-}
-function createClient(options) {
-  const clientOptions = options;
-  const throttleDelay = getThrottle(clientOptions.throttle ?? DEFAULT_THROTTLE);
-  const lostConnectionTimeout = getLostConnectionTimeout(
-    clientOptions.lostConnectionTimeout ?? DEFAULT_LOST_CONNECTION_TIMEOUT
-  );
-  const backgroundKeepAliveTimeout = getBackgroundKeepAliveTimeout(
-    clientOptions.backgroundKeepAliveTimeout
-  );
-  const authManager = createAuthManager(options);
-  const roomsById = /* @__PURE__ */ new Map();
-  function teardownRoom(room) {
-    unlinkDevTools(room.id);
-    roomsById.delete(room.id);
-    room.destroy();
-  }
-  function leaseRoom(info) {
-    const leave = () => {
-      const self = leave;
-      if (!info.unsubs.delete(self)) {
-        warn(
-          "This leave function was already called. Calling it more than once has no effect."
-        );
-      } else {
-        if (info.unsubs.size === 0) {
-          teardownRoom(info.room);
-        }
-      }
-    };
-    info.unsubs.add(leave);
-    return {
-      room: info.room,
-      leave
-    };
-  }
-  function enterRoom(roomId, options2) {
-    const existing = roomsById.get(roomId);
-    if (existing !== void 0) {
-      return leaseRoom(existing);
-    }
-    deprecateIf(
-      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 ?? {},
-        initialStorage: options2.initialStorage
-      },
-      {
-        roomId,
-        throttleDelay,
-        lostConnectionTimeout,
-        backgroundKeepAliveTimeout,
-        polyfills: clientOptions.polyfills,
-        delegates: clientOptions.mockedDelegates ?? {
-          createSocket: makeCreateSocketDelegateForRoom(
-            roomId,
-            baseUrl,
-            clientOptions.polyfills?.WebSocket
-          ),
-          authenticate: makeAuthDelegateForRoom(roomId, authManager)
-        },
-        enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: options2?.unstable_batchedUpdates,
-        baseUrl,
-        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP
-      }
-    );
-    const newRoomInfo = {
-      room: newRoom,
-      unsubs: /* @__PURE__ */ new Set()
-    };
-    roomsById.set(roomId, newRoomInfo);
-    setupDevTools(() => Array.from(roomsById.keys()));
-    linkDevTools(roomId, newRoom);
-    const shouldConnect = options2.autoConnect ?? options2.shouldInitiallyConnect ?? true;
-    if (shouldConnect) {
-      if (typeof atob === "undefined") {
-        if (clientOptions.polyfills?.atob === void 0) {
-          throw new Error(
-            "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
-          );
-        }
-        global.atob = clientOptions.polyfills.atob;
-      }
-      newRoom.connect();
-    }
-    return leaseRoom(newRoomInfo);
-  }
-  function enter(roomId, options2) {
-    const { room, leave: _ } = enterRoom(roomId, options2);
-    return room;
-  }
-  function getRoom(roomId) {
-    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 logout() {
-    authManager.reset();
-    for (const { room } of roomsById.values()) {
-      if (!isIdle(room.getStatus())) {
-        room.reconnect();
-      }
-    }
-  }
-  return {
-    logout,
-    // Old, deprecated APIs
-    enter,
-    getRoom,
-    leave: forceLeave,
-    // New, preferred API
-    enterRoom
-  };
-}
-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
-  );
-}
-
-// src/crdts/utils.ts
-function toPlainLson(lson) {
-  if (lson instanceof LiveObject) {
-    return {
-      liveblocksType: "LiveObject",
-      data: Object.fromEntries(
-        Object.entries(lson.toObject()).flatMap(
-          ([key, value]) => value !== void 0 ? [[key, toPlainLson(value)]] : []
-        )
-      )
-    };
-  } else if (lson instanceof LiveMap) {
-    return {
-      liveblocksType: "LiveMap",
-      data: Object.fromEntries(
-        [...lson].map(([key, value]) => [key, toPlainLson(value)])
-      )
-    };
-  } else if (lson instanceof LiveList) {
-    return {
-      liveblocksType: "LiveList",
-      data: [...lson].map((item) => toPlainLson(item))
-    };
-  } else {
-    return lson;
-  }
-}
-
-// src/immutable.ts
-function lsonObjectToJson(obj) {
-  const result = {};
-  for (const key in obj) {
-    const val = obj[key];
-    if (val !== void 0) {
-      result[key] = lsonToJson(val);
-    }
-  }
-  return result;
-}
-function liveObjectToJson(liveObject) {
-  return lsonObjectToJson(liveObject.toObject());
-}
-function liveMapToJson(map) {
-  const result = {};
-  for (const [key, value] of map.entries()) {
-    result[key] = lsonToJson(value);
-  }
-  return result;
-}
-function lsonListToJson(value) {
-  return value.map(lsonToJson);
-}
-function liveListToJson(value) {
-  return lsonListToJson(value.toArray());
-}
-function lsonToJson(value) {
-  if (value instanceof LiveObject) {
-    return liveObjectToJson(value);
-  } else if (value instanceof LiveList) {
-    return liveListToJson(value);
-  } else if (value instanceof LiveMap) {
-    return liveMapToJson(value);
-  } else if (value instanceof LiveRegister) {
-    return value.data;
-  }
-  if (Array.isArray(value)) {
-    return lsonListToJson(value);
-  } else if (isPlainObject(value)) {
-    return lsonObjectToJson(value);
-  }
-  return value;
-}
-function deepLiveify(value) {
-  if (Array.isArray(value)) {
-    return new LiveList(value.map(deepLiveify));
-  } else if (isPlainObject(value)) {
-    const init = {};
-    for (const key in value) {
-      const val = value[key];
-      if (val === void 0) {
-        continue;
-      }
-      init[key] = deepLiveify(val);
-    }
-    return new LiveObject(init);
-  } else {
-    return value;
-  }
-}
-function patchLiveList(liveList, prev, next) {
-  let i = 0;
-  let prevEnd = prev.length - 1;
-  let nextEnd = next.length - 1;
-  let prevNode = prev[0];
-  let nextNode = next[0];
-  outer: {
-    while (prevNode === nextNode) {
-      ++i;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[i];
-      nextNode = next[i];
-    }
-    prevNode = prev[prevEnd];
-    nextNode = next[nextEnd];
-    while (prevNode === nextNode) {
-      prevEnd--;
-      nextEnd--;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[prevEnd];
-      nextNode = next[nextEnd];
-    }
-  }
-  if (i > prevEnd) {
-    if (i <= nextEnd) {
-      while (i <= nextEnd) {
-        liveList.insert(deepLiveify(next[i]), i);
-        i++;
-      }
-    }
-  } else if (i > nextEnd) {
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
-  } else {
-    while (i <= prevEnd && i <= nextEnd) {
-      prevNode = prev[i];
-      nextNode = next[i];
-      const liveListNode = liveList.get(i);
-      if (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
-        patchLiveObject(liveListNode, prevNode, nextNode);
-      } else {
-        liveList.set(i, deepLiveify(nextNode));
-      }
-      i++;
-    }
-    while (i <= nextEnd) {
-      liveList.insert(deepLiveify(next[i]), i);
-      i++;
-    }
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
-  }
-}
-function patchLiveObjectKey(liveObject, key, prev, next) {
-  if (process.env.NODE_ENV !== "production") {
-    const nonSerializableValue = findNonSerializableValue(next);
-    if (nonSerializableValue) {
-      error2(
-        `New state path: '${nonSerializableValue.path}' value: '${String(
-          nonSerializableValue.value
-        )}' is not serializable.
-Only serializable value can be synced with Liveblocks.`
-      );
-      return;
-    }
-  }
-  const value = liveObject.get(key);
-  if (next === void 0) {
-    liveObject.delete(key);
-  } else if (value === void 0) {
-    liveObject.set(key, deepLiveify(next));
-  } else if (prev === next) {
-    return;
-  } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
-    patchLiveList(value, prev, next);
-  } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
-    patchLiveObject(value, prev, next);
-  } else {
-    liveObject.set(key, deepLiveify(next));
-  }
-}
-function patchLiveObject(root, prev, next) {
-  const updates = {};
-  for (const key in next) {
-    patchLiveObjectKey(root, key, prev[key], next[key]);
-  }
-  for (const key in prev) {
-    if (next[key] === void 0) {
-      root.delete(key);
-    }
-  }
-  if (Object.keys(updates).length > 0) {
-    root.update(updates);
-  }
-}
-function getParentsPath(node) {
-  const path = [];
-  while (node.parent.type === "HasParent") {
-    if (isLiveList(node.parent.node)) {
-      path.push(node.parent.node._indexOfPosition(node.parent.key));
-    } else {
-      path.push(node.parent.key);
-    }
-    node = node.parent.node;
-  }
-  return path;
-}
-function legacy_patchImmutableObject(state, updates) {
-  return updates.reduce(
-    (state2, update) => legacy_patchImmutableObjectWithUpdate(state2, update),
-    state
-  );
-}
-function legacy_patchImmutableObjectWithUpdate(state, update) {
-  const path = getParentsPath(update.node);
-  return legacy_patchImmutableNode(state, path, update);
-}
-function legacy_patchImmutableNode(state, path, update) {
-  const pathItem = path.pop();
-  if (pathItem === void 0) {
-    switch (update.type) {
-      case "LiveObject": {
-        if (!isJsonObject(state)) {
-          throw new Error(
-            "Internal: received update on LiveObject but state was not an object"
-          );
-        }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (update.updates[key]?.type === "update") {
-            const val = update.node.get(key);
-            if (val !== void 0) {
-              newState[key] = lsonToJson(val);
-            }
-          } else if (update.updates[key]?.type === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-      case "LiveList": {
-        if (!Array.isArray(state)) {
-          throw new Error(
-            "Internal: received update on LiveList but state was not an array"
-          );
-        }
-        let newState = state.map((x) => x);
-        for (const listUpdate of update.updates) {
-          if (listUpdate.type === "set") {
-            newState = newState.map(
-              (item, index) => index === listUpdate.index ? lsonToJson(listUpdate.item) : item
-            );
-          } else if (listUpdate.type === "insert") {
-            if (listUpdate.index === newState.length) {
-              newState.push(lsonToJson(listUpdate.item));
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index)
-              ];
-            }
-          } else if (listUpdate.type === "delete") {
-            newState.splice(listUpdate.index, 1);
-          } else if (listUpdate.type === "move") {
-            if (listUpdate.previousIndex > listUpdate.index) {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
-                ...newState.slice(listUpdate.previousIndex + 1)
-              ];
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.previousIndex),
-                ...newState.slice(
-                  listUpdate.previousIndex + 1,
-                  listUpdate.index + 1
-                ),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index + 1)
-              ];
-            }
-          }
-        }
-        return newState;
-      }
-      case "LiveMap": {
-        if (!isJsonObject(state)) {
-          throw new Error(
-            "Internal: received update on LiveMap but state was not an object"
-          );
+            return cb(others, internalEvent);
+          });
         }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (update.updates[key]?.type === "update") {
-            const value = update.node.get(key);
-            if (value !== void 0) {
-              newState[key] = lsonToJson(value);
-            }
-          } else if (update.updates[key]?.type === "delete") {
-            delete newState[key];
-          }
+        case "error":
+          return events.error.subscribe(callback);
+        case "connection": {
+          const cb = callback;
+          return events.status.subscribe(
+            (status) => cb(newToLegacyStatus(status))
+          );
         }
-        return newState;
+        case "status":
+          return events.status.subscribe(callback);
+        case "lost-connection":
+          return events.lostConnection.subscribe(
+            callback
+          );
+        case "history":
+          return events.history.subscribe(callback);
+        case "storage-status":
+          return events.storageStatus.subscribe(
+            callback
+          );
+        default:
+          return assertNever(
+            first,
+            `"${String(first)}" is not a valid event name`
+          );
       }
     }
-  }
-  if (Array.isArray(state)) {
-    const newArray = [...state];
-    newArray[pathItem] = legacy_patchImmutableNode(
-      state[pathItem],
-      path,
-      update
-    );
-    return newArray;
-  } else if (isJsonObject(state)) {
-    const node = state[pathItem];
-    if (node === void 0) {
-      return state;
-    } else {
-      const stateAsObj = state;
-      return {
-        ...stateAsObj,
-        [pathItem]: legacy_patchImmutableNode(node, path, update)
-      };
+    if (second === void 0 || typeof first === "function") {
+      if (typeof first === "function") {
+        const storageCallback = first;
+        return events.storage.subscribe(storageCallback);
+      } else {
+        throw new Error("Please specify a listener callback");
+      }
     }
-  } else {
-    return state;
-  }
-}
-
-// 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;
+    if (isLiveNode(first)) {
+      const node = first;
+      if (options?.isDeep) {
+        const storageCallback = second;
+        return subscribeToLiveStructureDeeply(node, storageCallback);
+      } else {
+        const nodeCallback = second;
+        return subscribeToLiveStructureShallowly(node, nodeCallback);
+      }
     }
+    throw new Error(
+      `${String(first)} is not a value that can be subscribed to.`
+    );
   }
-  return true;
+  return subscribe;
 }
-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 isRoomEventName(value) {
+  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "history" || value === "status" || value === "storage-status" || value === "lost-connection" || value === "connection";
 }
-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;
+function makeAuthDelegateForRoom(roomId, authManager) {
+  return async () => {
+    return authManager.getAuthValue("room:read", roomId);
+  };
+}
+function makeCreateSocketDelegateForRoom(roomId, baseUrl, WebSocketPolyfill) {
+  return (authValue) => {
+    const ws = WebSocketPolyfill ?? (typeof WebSocket === "undefined" ? void 0 : WebSocket);
+    if (ws === void 0) {
+      throw new StopRetrying(
+        "To use Liveblocks client in a non-DOM environment, you need to provide a WebSocket polyfill."
+      );
     }
-    return shallowArray(a, b);
-  }
-  return shallowObj(a, b);
+    const url = new URL(baseUrl);
+    url.protocol = url.protocol === "http:" ? "ws" : "wss";
+    url.pathname = "/v7";
+    url.searchParams.set("roomId", roomId);
+    if (authValue.type === "secret") {
+      url.searchParams.set("tok", authValue.token.raw);
+    } else if (authValue.type === "public") {
+      url.searchParams.set("pubkey", authValue.publicApiKey);
+    } else {
+      return assertNever(authValue, "Unhandled case");
+    }
+    url.searchParams.set("version", PKG_VERSION || "dev");
+    return new ws(url.toString());
+  };
 }
 
-// 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;
+// src/client.ts
+var MIN_THROTTLE = 16;
+var MAX_THROTTLE = 1e3;
+var DEFAULT_THROTTLE = 100;
+var MIN_BACKGROUND_KEEP_ALIVE_TIMEOUT = 15e3;
+var MIN_LOST_CONNECTION_TIMEOUT = 200;
+var RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT = 1e3;
+var MAX_LOST_CONNECTION_TIMEOUT = 3e4;
+var DEFAULT_LOST_CONNECTION_TIMEOUT = 5e3;
+function getBaseUrlFromClientOptions(clientOptions) {
+  if ("liveblocksServer" in clientOptions) {
+    throw new Error("Client option no longer supported");
+  }
+  if (typeof clientOptions.baseUrl === "string" && clientOptions.baseUrl.startsWith("http")) {
+    return clientOptions.baseUrl;
   } else {
-    return shallow(a.data, b.data) && shallow(a.error, b.error);
+    return DEFAULT_BASE_URL;
   }
 }
-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);
+function createClient(options) {
+  const clientOptions = options;
+  const throttleDelay = getThrottle(clientOptions.throttle ?? DEFAULT_THROTTLE);
+  const lostConnectionTimeout = getLostConnectionTimeout(
+    clientOptions.lostConnectionTimeout ?? DEFAULT_LOST_CONNECTION_TIMEOUT
+  );
+  const backgroundKeepAliveTimeout = getBackgroundKeepAliveTimeout(
+    clientOptions.backgroundKeepAliveTimeout
+  );
+  const authManager = createAuthManager(options);
+  const roomsById = /* @__PURE__ */ new Map();
+  function teardownRoom(room) {
+    unlinkDevTools(room.id);
+    roomsById.delete(room.id);
+    room.destroy();
+  }
+  function leaseRoom(info) {
+    const leave = () => {
+      const self = leave;
+      if (!info.unsubs.delete(self)) {
+        warn(
+          "This leave function was already called. Calling it more than once has no effect."
+        );
+      } else {
+        if (info.unsubs.size === 0) {
+          teardownRoom(info.room);
+        }
+      }
+    };
+    info.unsubs.add(leave);
+    return {
+      room: info.room,
+      leave
+    };
+  }
+  function enterRoom(roomId, options2) {
+    const existing = roomsById.get(roomId);
+    if (existing !== void 0) {
+      return leaseRoom(existing);
+    }
+    deprecateIf(
+      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 ?? {},
+        initialStorage: options2.initialStorage
+      },
+      {
+        roomId,
+        throttleDelay,
+        lostConnectionTimeout,
+        backgroundKeepAliveTimeout,
+        polyfills: clientOptions.polyfills,
+        delegates: clientOptions.mockedDelegates ?? {
+          createSocket: makeCreateSocketDelegateForRoom(
+            roomId,
+            baseUrl,
+            clientOptions.polyfills?.WebSocket
+          ),
+          authenticate: makeAuthDelegateForRoom(roomId, authManager)
+        },
+        enableDebugLogging: clientOptions.enableDebugLogging,
+        unstable_batchedUpdates: options2?.unstable_batchedUpdates,
+        baseUrl,
+        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP
+      }
+    );
+    const newRoomInfo = {
+      room: newRoom,
+      unsubs: /* @__PURE__ */ new Set()
+    };
+    roomsById.set(roomId, newRoomInfo);
+    setupDevTools(() => Array.from(roomsById.keys()));
+    linkDevTools(roomId, newRoom);
+    const shouldConnect = options2.autoConnect ?? options2.shouldInitiallyConnect ?? true;
+    if (shouldConnect) {
+      if (typeof atob === "undefined") {
+        if (clientOptions.polyfills?.atob === void 0) {
+          throw new Error(
+            "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
+          );
+        }
+        global.atob = clientOptions.polyfills.atob;
+      }
+      newRoom.connect();
     }
+    return leaseRoom(newRoomInfo);
   }
-  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();
+  function enter(roomId, options2) {
+    const { room, leave: _ } = enterRoom(roomId, options2);
+    return room;
   }
-  async function revalidate() {
-    context.isInvalid = true;
-    return get();
+  function getRoom(roomId) {
+    const room = roomsById.get(roomId)?.room;
+    return room ? room : null;
   }
-  async function get() {
-    if (context.isInvalid) {
-      if (!context.promise) {
-        context.isInvalid = true;
-        context.promise = $asyncFunction();
-        state = { isLoading: true, data: state.data };
-        notify();
-      }
-      await resolve();
+  function forceLeave(roomId) {
+    const unsubs = roomsById.get(roomId)?.unsubs ?? /* @__PURE__ */ new Set();
+    for (const unsub of unsubs) {
+      unsub();
     }
-    return getState();
   }
-  function getState() {
-    return state;
+  function logout() {
+    authManager.reset();
+    for (const { room } of roomsById.values()) {
+      if (!isIdle(room.getStatus())) {
+        room.reconnect();
+      }
+    }
   }
   return {
-    ...eventSource2.observable,
-    get,
-    getState,
-    revalidate
+    logout,
+    // Old, deprecated APIs
+    enter,
+    getRoom,
+    leave: forceLeave,
+    // New, preferred API
+    enterRoom
   };
 }
-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 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}.`
+    );
   }
-  function getState(key) {
-    return cache.get(key)?.getState();
+  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
+  );
+}
+
+// src/crdts/utils.ts
+function toPlainLson(lson) {
+  if (lson instanceof LiveObject) {
+    return {
+      liveblocksType: "LiveObject",
+      data: Object.fromEntries(
+        Object.entries(lson.toObject()).flatMap(
+          ([key, value]) => value !== void 0 ? [[key, toPlainLson(value)]] : []
+        )
+      )
+    };
+  } else if (lson instanceof LiveMap) {
+    return {
+      liveblocksType: "LiveMap",
+      data: Object.fromEntries(
+        [...lson].map(([key, value]) => [key, toPlainLson(value)])
+      )
+    };
+  } else if (lson instanceof LiveList) {
+    return {
+      liveblocksType: "LiveList",
+      data: [...lson].map((item) => toPlainLson(item))
+    };
+  } else {
+    return lson;
   }
-  function revalidate(key) {
-    return create(key).revalidate();
+}
+
+// src/immutable.ts
+function lsonObjectToJson(obj) {
+  const result = {};
+  for (const key in obj) {
+    const val = obj[key];
+    if (val !== void 0) {
+      result[key] = lsonToJson(val);
+    }
   }
-  function subscribe(key, callback) {
-    return create(key).subscribe(callback) ?? noop;
+  return result;
+}
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
+function liveMapToJson(map) {
+  const result = {};
+  for (const [key, value] of map.entries()) {
+    result[key] = lsonToJson(value);
   }
-  function subscribeOnce(key, callback) {
-    return create(key).subscribeOnce(callback) ?? noop;
+  return result;
+}
+function lsonListToJson(value) {
+  return value.map(lsonToJson);
+}
+function liveListToJson(value) {
+  return lsonListToJson(value.toArray());
+}
+function lsonToJson(value) {
+  if (value instanceof LiveObject) {
+    return liveObjectToJson(value);
+  } else if (value instanceof LiveList) {
+    return liveListToJson(value);
+  } else if (value instanceof LiveMap) {
+    return liveMapToJson(value);
+  } else if (value instanceof LiveRegister) {
+    return value.data;
   }
-  function has(key) {
-    return cache.has(key);
+  if (Array.isArray(value)) {
+    return lsonListToJson(value);
+  } else if (isPlainObject(value)) {
+    return lsonObjectToJson(value);
   }
-  function clear() {
-    cache.clear();
+  return value;
+}
+function deepLiveify(value) {
+  if (Array.isArray(value)) {
+    return new LiveList(value.map(deepLiveify));
+  } else if (isPlainObject(value)) {
+    const init = {};
+    for (const key in value) {
+      const val = value[key];
+      if (val === void 0) {
+        continue;
+      }
+      init[key] = deepLiveify(val);
+    }
+    return new LiveObject(init);
+  } else {
+    return value;
   }
-  return {
-    create,
-    get,
-    getState,
-    revalidate,
-    subscribe,
-    subscribeOnce,
-    has,
-    clear
-  };
 }
-
-// src/lib/Poller.ts
-function makePoller(callback) {
-  let context = {
-    state: "stopped",
-    timeoutHandle: null,
-    interval: null,
-    lastScheduledAt: null,
-    remainingInterval: null
-  };
-  function poll() {
-    if (context.state === "running") {
-      schedule(context.interval);
+function patchLiveList(liveList, prev, next) {
+  let i = 0;
+  let prevEnd = prev.length - 1;
+  let nextEnd = next.length - 1;
+  let prevNode = prev[0];
+  let nextNode = next[0];
+  outer: {
+    while (prevNode === nextNode) {
+      ++i;
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+      prevNode = prev[i];
+      nextNode = next[i];
+    }
+    prevNode = prev[prevEnd];
+    nextNode = next[nextEnd];
+    while (prevNode === nextNode) {
+      prevEnd--;
+      nextEnd--;
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+      prevNode = prev[prevEnd];
+      nextNode = next[nextEnd];
     }
-    void callback();
-  }
-  function schedule(interval) {
-    context = {
-      state: "running",
-      interval: context.state !== "stopped" ? context.interval : interval,
-      lastScheduledAt: performance.now(),
-      timeoutHandle: setTimeout(poll, interval),
-      remainingInterval: null
-    };
   }
-  function scheduleRemaining(remaining) {
-    if (context.state !== "paused") {
-      return;
+  if (i > prevEnd) {
+    if (i <= nextEnd) {
+      while (i <= nextEnd) {
+        liveList.insert(deepLiveify(next[i]), i);
+        i++;
+      }
+    }
+  } else if (i > nextEnd) {
+    let localI = i;
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
+    }
+  } else {
+    while (i <= prevEnd && i <= nextEnd) {
+      prevNode = prev[i];
+      nextNode = next[i];
+      const liveListNode = liveList.get(i);
+      if (isLiveObject(liveListNode) && isPlainObject(prevNode) && isPlainObject(nextNode)) {
+        patchLiveObject(liveListNode, prevNode, nextNode);
+      } else {
+        liveList.set(i, deepLiveify(nextNode));
+      }
+      i++;
+    }
+    while (i <= nextEnd) {
+      liveList.insert(deepLiveify(next[i]), i);
+      i++;
+    }
+    let localI = i;
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
     }
-    context = {
-      state: "running",
-      interval: context.interval,
-      lastScheduledAt: context.lastScheduledAt,
-      timeoutHandle: setTimeout(poll, remaining),
-      remainingInterval: null
-    };
   }
-  function start(interval) {
-    if (context.state === "running") {
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+  if (process.env.NODE_ENV !== "production") {
+    const nonSerializableValue = findNonSerializableValue(next);
+    if (nonSerializableValue) {
+      error2(
+        `New state path: '${nonSerializableValue.path}' value: '${String(
+          nonSerializableValue.value
+        )}' is not serializable.
+Only serializable value can be synced with Liveblocks.`
+      );
       return;
     }
-    schedule(interval);
   }
-  function restart(interval) {
-    stop();
-    start(interval);
+  const value = liveObject.get(key);
+  if (next === void 0) {
+    liveObject.delete(key);
+  } else if (value === void 0) {
+    liveObject.set(key, deepLiveify(next));
+  } else if (prev === next) {
+    return;
+  } else if (isLiveList(value) && Array.isArray(prev) && Array.isArray(next)) {
+    patchLiveList(value, prev, next);
+  } else if (isLiveObject(value) && isPlainObject(prev) && isPlainObject(next)) {
+    patchLiveObject(value, prev, next);
+  } else {
+    liveObject.set(key, deepLiveify(next));
   }
-  function pause() {
-    if (context.state !== "running") {
-      return;
-    }
-    clearTimeout(context.timeoutHandle);
-    context = {
-      state: "paused",
-      interval: context.interval,
-      lastScheduledAt: context.lastScheduledAt,
-      timeoutHandle: null,
-      remainingInterval: context.interval - (performance.now() - context.lastScheduledAt)
-    };
+}
+function patchLiveObject(root, prev, next) {
+  const updates = {};
+  for (const key in next) {
+    patchLiveObjectKey(root, key, prev[key], next[key]);
   }
-  function resume() {
-    if (context.state !== "paused") {
-      return;
+  for (const key in prev) {
+    if (next[key] === void 0) {
+      root.delete(key);
     }
-    scheduleRemaining(context.remainingInterval);
   }
-  function stop() {
-    if (context.state === "stopped") {
-      return;
-    }
-    if (context.timeoutHandle) {
-      clearTimeout(context.timeoutHandle);
+  if (Object.keys(updates).length > 0) {
+    root.update(updates);
+  }
+}
+function getParentsPath(node) {
+  const path = [];
+  while (node.parent.type === "HasParent") {
+    if (isLiveList(node.parent.node)) {
+      path.push(node.parent.node._indexOfPosition(node.parent.key));
+    } else {
+      path.push(node.parent.key);
     }
-    context = {
-      state: "stopped",
-      interval: null,
-      lastScheduledAt: null,
-      timeoutHandle: null,
-      remainingInterval: null
-    };
+    node = node.parent.node;
   }
-  return {
-    start,
-    restart,
-    pause,
-    resume,
-    stop
-  };
+  return path;
 }
-
-// src/lib/stringify.ts
-function stringify(object, ...args) {
-  if (typeof object !== "object" || object === null || Array.isArray(object)) {
-    return JSON.stringify(object, ...args);
+function legacy_patchImmutableObject(state, updates) {
+  return updates.reduce(
+    (state2, update) => legacy_patchImmutableObjectWithUpdate(state2, update),
+    state
+  );
+}
+function legacy_patchImmutableObjectWithUpdate(state, update) {
+  const path = getParentsPath(update.node);
+  return legacy_patchImmutableNode(state, path, update);
+}
+function legacy_patchImmutableNode(state, path, update) {
+  const pathItem = path.pop();
+  if (pathItem === void 0) {
+    switch (update.type) {
+      case "LiveObject": {
+        if (!isJsonObject(state)) {
+          throw new Error(
+            "Internal: received update on LiveObject but state was not an object"
+          );
+        }
+        const newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (update.updates[key]?.type === "update") {
+            const val = update.node.get(key);
+            if (val !== void 0) {
+              newState[key] = lsonToJson(val);
+            }
+          } else if (update.updates[key]?.type === "delete") {
+            delete newState[key];
+          }
+        }
+        return newState;
+      }
+      case "LiveList": {
+        if (!Array.isArray(state)) {
+          throw new Error(
+            "Internal: received update on LiveList but state was not an array"
+          );
+        }
+        let newState = state.map((x) => x);
+        for (const listUpdate of update.updates) {
+          if (listUpdate.type === "set") {
+            newState = newState.map(
+              (item, index) => index === listUpdate.index ? lsonToJson(listUpdate.item) : item
+            );
+          } else if (listUpdate.type === "insert") {
+            if (listUpdate.index === newState.length) {
+              newState.push(lsonToJson(listUpdate.item));
+            } else {
+              newState = [
+                ...newState.slice(0, listUpdate.index),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index)
+              ];
+            }
+          } else if (listUpdate.type === "delete") {
+            newState.splice(listUpdate.index, 1);
+          } else if (listUpdate.type === "move") {
+            if (listUpdate.previousIndex > listUpdate.index) {
+              newState = [
+                ...newState.slice(0, listUpdate.index),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
+                ...newState.slice(listUpdate.previousIndex + 1)
+              ];
+            } else {
+              newState = [
+                ...newState.slice(0, listUpdate.previousIndex),
+                ...newState.slice(
+                  listUpdate.previousIndex + 1,
+                  listUpdate.index + 1
+                ),
+                lsonToJson(listUpdate.item),
+                ...newState.slice(listUpdate.index + 1)
+              ];
+            }
+          }
+        }
+        return newState;
+      }
+      case "LiveMap": {
+        if (!isJsonObject(state)) {
+          throw new Error(
+            "Internal: received update on LiveMap but state was not an object"
+          );
+        }
+        const newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (update.updates[key]?.type === "update") {
+            const value = update.node.get(key);
+            if (value !== void 0) {
+              newState[key] = lsonToJson(value);
+            }
+          } else if (update.updates[key]?.type === "delete") {
+            delete newState[key];
+          }
+        }
+        return newState;
+      }
+    }
+  }
+  if (Array.isArray(state)) {
+    const newArray = [...state];
+    newArray[pathItem] = legacy_patchImmutableNode(
+      state[pathItem],
+      path,
+      update
+    );
+    return newArray;
+  } else if (isJsonObject(state)) {
+    const node = state[pathItem];
+    if (node === void 0) {
+      return state;
+    } else {
+      const stateAsObj = state;
+      return {
+        ...stateAsObj,
+        [pathItem]: legacy_patchImmutableNode(node, path, update)
+      };
+    }
+  } else {
+    return state;
   }
-  const sortedObject = Object.keys(object).sort().reduce(
-    (sortedObject2, key) => {
-      sortedObject2[key] = object[key];
-      return sortedObject2;
-    },
-    {}
-  );
-  return JSON.stringify(sortedObject, ...args);
 }
 
-// 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;
+// src/lib/shallow.ts
+function shallowArray(xs, ys) {
+  if (xs.length !== ys.length) {
+    return false;
   }
-  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);
-        }
-      }
+  for (let i = 0; i < xs.length; i++) {
+    if (!Object.is(xs[i], ys[i])) {
+      return false;
     }
   }
+  return true;
 }
-function getMentionedIdsFromCommentBody(body) {
-  const mentionedIds = /* @__PURE__ */ new Set();
-  traverseCommentBody(
-    body,
-    "mention",
-    (mention) => mentionedIds.add(mention.id)
+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 Array.from(mentionedIds);
 }
-async function resolveUsersInCommentBody(body, resolveUsers) {
-  const resolvedUsers = /* @__PURE__ */ new Map();
-  if (!resolveUsers) {
-    return resolvedUsers;
+function shallow(a, b) {
+  if (Object.is(a, b)) {
+    return true;
   }
-  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);
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB) {
+      return false;
     }
+    return shallowArray(a, b);
   }
-  return resolvedUsers;
+  return shallowObj(a, b);
 }
-var htmlEscapables = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;"
+
+// src/lib/AsyncCache.ts
+var noop = () => {
 };
-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([""], []);
+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);
   }
-  return new HtmlSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
-  );
 }
-function escapeHtml(value) {
-  if (value instanceof HtmlSafeString) {
-    return value.toString();
+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);
+    }
   }
-  if (Array.isArray(value)) {
-    return joinHtml(value).toString();
+  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();
   }
-  return String(value).replace(
-    htmlEscapablesRegex,
-    (character) => htmlEscapables[character]
-  );
-}
-var HtmlSafeString = class {
-  constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
+  async function revalidate() {
+    context.isInvalid = true;
+    return get();
   }
-  toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeHtml(nn(this._values[i - 1])) + str;
-    });
+  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 html(strings, ...values) {
-  return new HtmlSafeString(strings, values);
+  function getState() {
+    return state;
+  }
+  return {
+    ...eventSource2.observable,
+    get,
+    getState,
+    revalidate
+  };
 }
-var markdownEscapables = {
-  _: "\\_",
-  "*": "\\*",
-  "#": "\\#",
-  "`": "\\`",
-  "~": "\\~",
-  "!": "\\!",
-  "|": "\\|",
-  "(": "\\(",
-  ")": "\\)",
-  "{": "\\{",
-  "}": "\\}",
-  "[": "\\[",
-  "]": "\\]"
-};
-var markdownEscapablesRegex = new RegExp(
-  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
-  "g"
-);
-function joinMarkdown(strings) {
-  if (strings.length <= 0) {
-    return new MarkdownSafeString([""], []);
+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();
   }
-  return new MarkdownSafeString(
-    ["", ...Array(strings.length - 1).fill(""), ""],
-    strings
-  );
-}
-function escapeMarkdown(value) {
-  if (value instanceof MarkdownSafeString) {
-    return value.toString();
+  function revalidate(key) {
+    return create(key).revalidate();
   }
-  if (Array.isArray(value)) {
-    return joinMarkdown(value).toString();
+  function subscribe(key, callback) {
+    return create(key).subscribe(callback) ?? noop;
   }
-  return String(value).replace(
-    markdownEscapablesRegex,
-    (character) => markdownEscapables[character]
-  );
-}
-var MarkdownSafeString = class {
-  constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
+  function subscribeOnce(key, callback) {
+    return create(key).subscribeOnce(callback) ?? noop;
   }
-  toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeMarkdown(nn(this._values[i - 1])) + str;
-    });
+  function has(key) {
+    return cache.has(key);
   }
-};
-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;
+  function clear() {
+    cache.clear();
   }
-  return;
+  return {
+    create,
+    get,
+    getState,
+    revalidate,
+    subscribe,
+    subscribeOnce,
+    has,
+    clear
+  };
 }
-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>`;
+
+// src/lib/Poller.ts
+function makePoller(callback) {
+  let context = {
+    state: "stopped",
+    timeoutHandle: null,
+    interval: null,
+    lastScheduledAt: null,
+    remainingInterval: null
+  };
+  function poll() {
+    if (context.state === "running") {
+      schedule(context.interval);
     }
-    if (element.code) {
-      children = html`<code>${children}</code>`;
+    void callback();
+  }
+  function schedule(interval) {
+    context = {
+      state: "running",
+      interval: context.state !== "stopped" ? context.interval : interval,
+      lastScheduledAt: performance.now(),
+      timeoutHandle: setTimeout(poll, interval),
+      remainingInterval: null
+    };
+  }
+  function scheduleRemaining(remaining) {
+    if (context.state !== "paused") {
+      return;
     }
-    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>`;
+    context = {
+      state: "running",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: setTimeout(poll, remaining),
+      remainingInterval: null
+    };
   }
-};
-var stringifyCommentBodyMarkdownElements = {
-  paragraph: ({ children }) => {
-    return children;
-  },
-  text: ({ element }) => {
-    let children = element.text;
-    if (!children) {
-      return children;
+  function start(interval) {
+    if (context.state === "running") {
+      return;
     }
-    if (element.bold) {
-      children = markdown`**${children}**`;
+    schedule(interval);
+  }
+  function restart(interval) {
+    stop();
+    start(interval);
+  }
+  function pause() {
+    if (context.state !== "running") {
+      return;
     }
-    if (element.italic) {
-      children = markdown`_${children}_`;
+    clearTimeout(context.timeoutHandle);
+    context = {
+      state: "paused",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: null,
+      remainingInterval: context.interval - (performance.now() - context.lastScheduledAt)
+    };
+  }
+  function resume() {
+    if (context.state !== "paused") {
+      return;
     }
-    if (element.strikethrough) {
-      children = markdown`~~${children}~~`;
+    scheduleRemaining(context.remainingInterval);
+  }
+  function stop() {
+    if (context.state === "stopped") {
+      return;
     }
-    if (element.code) {
-      children = markdown`\`${children}\``;
+    if (context.timeoutHandle) {
+      clearTimeout(context.timeoutHandle);
     }
-    return children;
-  },
-  link: ({ element, href }) => {
-    return markdown`[${element.url}](${href})`;
-  },
-  mention: ({ element, user }) => {
-    return markdown`@${user?.name ?? element.id}`;
+    context = {
+      state: "stopped",
+      interval: null,
+      lastScheduledAt: null,
+      timeoutHandle: null,
+      remainingInterval: null
+    };
   }
-};
-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
+  return {
+    start,
+    restart,
+    pause,
+    resume,
+    stop
   };
-  const resolvedUsers = await resolveUsersInCommentBody(
-    body,
-    options?.resolveUsers
+}
+
+// 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;
+    },
+    {}
   );
-  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 JSON.stringify(sortedObject, ...args);
 }
 
 // src/index.ts
@@ -7081,6 +7133,9 @@ export {
   b64decode,
   cloneLson,
   fancy_console_exports as console,
+  convertToCommentData,
+  convertToCommentUserReaction,
+  convertToThreadData,
   createAsyncCache,
   createClient,
   createCommentsApi,