@liveblocks/core 2.5.1 → 2.7.0-beta1

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.5.1";
+var PKG_VERSION = "2.7.0-beta1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -1859,8 +1859,7 @@ var Batch = class {
     this.clearDelayTimeout();
   }
 };
-function createBatchStore(callback, options) {
-  const batch = new Batch(callback, options);
+function createBatchStore(batch) {
   const cache = /* @__PURE__ */ new Map();
   const eventSource2 = makeEventSource();
   function getCacheKey(args) {
@@ -4749,9 +4748,19 @@ function findNonSerializableValue(value, path = "") {
   return false;
 }
 
+// src/lib/chunk.ts
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0, j = array.length; i < j; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+
 // src/lib/createIds.ts
 var THREAD_ID_PREFIX = "th";
 var COMMENT_ID_PREFIX = "cm";
+var COMMENT_ATTACHMENT_ID_PREFIX = "at";
 var INBOX_NOTIFICATION_ID_PREFIX = "in";
 function createOptimisticId(prefix) {
   return `${prefix}_${nanoid()}`;
@@ -4762,6 +4771,9 @@ function createThreadId() {
 function createCommentId() {
   return createOptimisticId(COMMENT_ID_PREFIX);
 }
+function createCommentAttachmentId() {
+  return createOptimisticId(COMMENT_ATTACHMENT_ID_PREFIX);
+}
 function createInboxNotificationId() {
   return createOptimisticId(INBOX_NOTIFICATION_ID_PREFIX);
 }
@@ -5164,6 +5176,22 @@ function installBackgroundTabSpy() {
   };
   return [inBackgroundSince, unsub];
 }
+var GET_ATTACHMENT_URLS_BATCH_DELAY = 50;
+var ATTACHMENT_PART_SIZE = 5 * 1024 * 1024;
+var ATTACHMENT_PART_BATCH_SIZE = 5;
+function splitFileIntoParts(file) {
+  const parts = [];
+  let start = 0;
+  while (start < file.size) {
+    const end = Math.min(start + ATTACHMENT_PART_SIZE, file.size);
+    parts.push({
+      partNumber: parts.length + 1,
+      part: file.slice(start, end)
+    });
+    start = end;
+  }
+  return parts;
+}
 var CommentsApiError = class extends Error {
   constructor(message, status, details) {
     super(message);
@@ -5172,429 +5200,138 @@ var CommentsApiError = class extends Error {
     this.details = details;
   }
 };
-function createCommentsApi(roomId, getAuthValue, fetchClientApi) {
-  async function fetchCommentsApi(endpoint, params, options) {
-    const authValue = await getAuthValue();
-    return fetchClientApi(roomId, endpoint, authValue, options, params);
-  }
-  async function fetchJson(endpoint, options, params) {
-    const response = await fetchCommentsApi(endpoint, params, options);
-    if (!response.ok) {
-      if (response.status >= 400 && response.status < 600) {
-        let error3;
-        try {
-          const errorBody = await response.json();
-          error3 = new CommentsApiError(
-            errorBody.message,
-            response.status,
-            errorBody
-          );
-        } catch {
-          error3 = new CommentsApiError(response.statusText, response.status);
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = {};
+var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY2 = 50;
+function createRoom(options, config) {
+  const initialPresence = options.initialPresence;
+  const initialStorage = options.initialStorage;
+  const [inBackgroundSince, uninstallBgTabSpy] = installBackgroundTabSpy();
+  const delegates = {
+    ...config.delegates,
+    // A connection is allowed to go into "zombie state" only if all of the
+    // following conditions apply:
+    //
+    // - The `backgroundKeepAliveTimeout` client option is configured
+    // - The browser window has been in the background for at least
+    //   `backgroundKeepAliveTimeout` milliseconds
+    // - There are no pending changes
+    //
+    canZombie() {
+      return config.backgroundKeepAliveTimeout !== void 0 && inBackgroundSince.current !== null && Date.now() > inBackgroundSince.current + config.backgroundKeepAliveTimeout && getStorageStatus() !== "synchronizing";
     }
-    return body;
-  }
-  async function getThreadsSince(options) {
-    const response = await fetchCommentsApi(
-      "/threads",
-      {
-        since: options?.since?.toISOString()
-      },
-      {
-        headers: {
-          "Content-Type": "application/json"
+  };
+  const managedSocket = new ManagedSocket(
+    delegates,
+    config.enableDebugLogging
+  );
+  const context = {
+    buffer: {
+      flushTimerID: void 0,
+      lastFlushedAt: 0,
+      presenceUpdates: (
+        // Queue up the initial presence message as a Full Presence™ update
+        {
+          type: "full",
+          data: initialPresence
+        }
+      ),
+      messages: [],
+      storageOperations: []
+    },
+    staticSessionInfo: new ValueRef(null),
+    dynamicSessionInfo: new ValueRef(null),
+    myPresence: new PatchableRef(initialPresence),
+    others: new OthersRef(),
+    initialStorage,
+    idFactory: null,
+    // Y.js
+    provider: void 0,
+    onProviderUpdate: makeEventSource(),
+    // Storage
+    clock: 0,
+    opClock: 0,
+    nodes: /* @__PURE__ */ new Map(),
+    root: void 0,
+    undoStack: [],
+    redoStack: [],
+    pausedHistory: null,
+    activeBatch: null,
+    unacknowledgedOps: /* @__PURE__ */ new Map(),
+    // Debug
+    opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
+  };
+  const doNotBatchUpdates = (cb) => cb();
+  const batchUpdates = config.unstable_batchedUpdates ?? doNotBatchUpdates;
+  let lastTokenKey;
+  function onStatusDidChange(newStatus) {
+    const authValue = managedSocket.authValue;
+    if (authValue !== null) {
+      const tokenKey = getAuthBearerHeaderFromAuthValue(authValue);
+      if (tokenKey !== lastTokenKey) {
+        lastTokenKey = tokenKey;
+        if (authValue.type === "secret") {
+          const token = authValue.token.parsed;
+          context.staticSessionInfo.set({
+            userId: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid,
+            userInfo: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.info : token.ui
+          });
+        } else {
+          context.staticSessionInfo.set({
+            userId: void 0,
+            userInfo: void 0
+          });
         }
       }
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        threads: {
-          updated: json.data.map(convertToThreadData),
-          deleted: json.deletedThreads.map(convertToThreadDeleteInfo)
-        },
-        inboxNotifications: {
-          updated: json.inboxNotifications.map(convertToInboxNotificationData),
-          deleted: json.deletedInboxNotifications.map(
-            convertToInboxNotificationDeleteInfo
-          )
-        },
-        requestedAt: new Date(json.meta.requestedAt)
-      };
-    } else if (response.status === 404) {
-      return {
-        threads: {
-          updated: [],
-          deleted: []
-        },
-        inboxNotifications: {
-          updated: [],
-          deleted: []
-        },
-        requestedAt: /* @__PURE__ */ new Date()
-      };
-    } else {
-      throw new Error("There was an error while getting threads.");
     }
+    batchUpdates(() => {
+      eventHub.status.notify(newStatus);
+      notifySelfChanged(doNotBatchUpdates);
+    });
   }
-  async function getThreads(options) {
-    let query;
-    if (options?.query) {
-      query = objectToQuery(options.query);
-    }
-    const response = await fetchCommentsApi(
-      "/threads",
-      {
-        query
-      },
-      {
-        headers: {
-          "Content-Type": "application/json"
+  let _connectionLossTimerId;
+  let _hasLostConnection = false;
+  function handleConnectionLossEvent(newStatus) {
+    if (newStatus === "reconnecting") {
+      _connectionLossTimerId = setTimeout(() => {
+        batchUpdates(() => {
+          eventHub.lostConnection.notify("lost");
+          _hasLostConnection = true;
+          context.others.clearOthers();
+          notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
+        });
+      }, config.lostConnectionTimeout);
+    } else {
+      clearTimeout(_connectionLossTimerId);
+      if (_hasLostConnection) {
+        if (newStatus === "disconnected") {
+          batchUpdates(() => {
+            eventHub.lostConnection.notify("failed");
+          });
+        } else {
+          batchUpdates(() => {
+            eventHub.lostConnection.notify("restored");
+          });
         }
+        _hasLostConnection = false;
       }
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        threads: json.data.map(convertToThreadData),
-        inboxNotifications: json.inboxNotifications.map(
-          convertToInboxNotificationData
-        ),
-        requestedAt: new Date(json.meta.requestedAt)
-      };
-    } else if (response.status === 404) {
-      return {
-        threads: [],
-        inboxNotifications: [],
-        deletedThreads: [],
-        deletedInboxNotifications: [],
-        requestedAt: /* @__PURE__ */ new Date()
-      };
-    } else {
-      throw new Error("There was an error while getting threads.");
     }
   }
-  async function getThread(threadId) {
-    const response = await fetchCommentsApi(
-      `/thread-with-notification/${threadId}`
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        thread: convertToThreadData(json.thread),
-        inboxNotification: json.inboxNotification ? convertToInboxNotificationData(json.inboxNotification) : void 0
-      };
-    } else if (response.status === 404) {
-      return {
-        thread: void 0,
-        inboxNotification: void 0
-      };
-    } else {
-      throw new Error(`There was an error while getting thread ${threadId}.`);
+  function onDidConnect() {
+    context.buffer.presenceUpdates = {
+      type: "full",
+      data: (
+        // Because context.me.current is a readonly object, we'll have to
+        // make a copy here. Otherwise, type errors happen later when
+        // "patching" my presence.
+        { ...context.myPresence.current }
+      )
+    };
+    if (_getStorage$ !== null) {
+      refreshStorage({ flush: false });
     }
+    flushNowOrSoon();
   }
-  async function createThread({
-    metadata,
-    body,
-    commentId = createCommentId(),
-    threadId = createThreadId()
-  }) {
-    const thread = await fetchJson("/threads", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        id: threadId,
-        comment: {
-          id: commentId,
-          body
-        },
-        metadata
-      })
-    });
-    return convertToThreadData(thread);
-  }
-  async function deleteThread(threadId) {
-    await fetchJson(`/threads/${encodeURIComponent(threadId)}`, {
-      method: "DELETE"
-    });
-  }
-  async function editThreadMetadata({
-    metadata,
-    threadId
-  }) {
-    return await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
-    );
-  }
-  async function markThreadAsResolved(threadId) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/mark-as-resolved`,
-      {
-        method: "POST"
-      }
-    );
-  }
-  async function markThreadAsUnresolved(threadId) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/mark-as-unresolved`,
-      {
-        method: "POST"
-      }
-    );
-  }
-  async function createComment({
-    threadId,
-    commentId = createCommentId(),
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: commentId,
-          body
-        })
-      }
-    );
-    return convertToCommentData(comment);
-  }
-  async function editComment({
-    threadId,
-    commentId,
-    body
-  }) {
-    const comment = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          body
-        })
-      }
-    );
-    return convertToCommentData(comment);
-  }
-  async function deleteComment2({
-    threadId,
-    commentId
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}`,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  async function addReaction2({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    const reaction = await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ emoji })
-      }
-    );
-    return convertToCommentUserReaction(reaction);
-  }
-  async function removeReaction2({
-    threadId,
-    commentId,
-    emoji
-  }) {
-    await fetchJson(
-      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
-        commentId
-      )}/reactions/${encodeURIComponent(emoji)}`,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  return {
-    getThreads,
-    getThreadsSince,
-    getThread,
-    createThread,
-    deleteThread,
-    editThreadMetadata,
-    markThreadAsResolved,
-    markThreadAsUnresolved,
-    createComment,
-    editComment,
-    deleteComment: deleteComment2,
-    addReaction: addReaction2,
-    removeReaction: removeReaction2
-  };
-}
-var MARK_INBOX_NOTIFICATIONS_AS_READ_BATCH_DELAY2 = 50;
-function createRoom(options, config) {
-  const initialPresence = options.initialPresence;
-  const initialStorage = options.initialStorage;
-  const [inBackgroundSince, uninstallBgTabSpy] = installBackgroundTabSpy();
-  const delegates = {
-    ...config.delegates,
-    // A connection is allowed to go into "zombie state" only if all of the
-    // following conditions apply:
-    //
-    // - The `backgroundKeepAliveTimeout` client option is configured
-    // - The browser window has been in the background for at least
-    //   `backgroundKeepAliveTimeout` milliseconds
-    // - There are no pending changes
-    //
-    canZombie() {
-      return config.backgroundKeepAliveTimeout !== void 0 && inBackgroundSince.current !== null && Date.now() > inBackgroundSince.current + config.backgroundKeepAliveTimeout && getStorageStatus() !== "synchronizing";
-    }
-  };
-  const managedSocket = new ManagedSocket(
-    delegates,
-    config.enableDebugLogging
-  );
-  const context = {
-    buffer: {
-      flushTimerID: void 0,
-      lastFlushedAt: 0,
-      presenceUpdates: (
-        // Queue up the initial presence message as a Full Presence™ update
-        {
-          type: "full",
-          data: initialPresence
-        }
-      ),
-      messages: [],
-      storageOperations: []
-    },
-    staticSessionInfo: new ValueRef(null),
-    dynamicSessionInfo: new ValueRef(null),
-    myPresence: new PatchableRef(initialPresence),
-    others: new OthersRef(),
-    initialStorage,
-    idFactory: null,
-    // Y.js
-    provider: void 0,
-    onProviderUpdate: makeEventSource(),
-    // Storage
-    clock: 0,
-    opClock: 0,
-    nodes: /* @__PURE__ */ new Map(),
-    root: void 0,
-    undoStack: [],
-    redoStack: [],
-    pausedHistory: null,
-    activeBatch: null,
-    unacknowledgedOps: /* @__PURE__ */ new Map(),
-    // Debug
-    opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
-  };
-  const doNotBatchUpdates = (cb) => cb();
-  const batchUpdates = config.unstable_batchedUpdates ?? doNotBatchUpdates;
-  let lastTokenKey;
-  function onStatusDidChange(newStatus) {
-    const authValue = managedSocket.authValue;
-    if (authValue !== null) {
-      const tokenKey = getAuthBearerHeaderFromAuthValue(authValue);
-      if (tokenKey !== lastTokenKey) {
-        lastTokenKey = tokenKey;
-        if (authValue.type === "secret") {
-          const token = authValue.token.parsed;
-          context.staticSessionInfo.set({
-            userId: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid,
-            userInfo: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.info : token.ui
-          });
-        } else {
-          context.staticSessionInfo.set({
-            userId: void 0,
-            userInfo: void 0
-          });
-        }
-      }
-    }
-    batchUpdates(() => {
-      eventHub.status.notify(newStatus);
-      notifySelfChanged(doNotBatchUpdates);
-    });
-  }
-  let _connectionLossTimerId;
-  let _hasLostConnection = false;
-  function handleConnectionLossEvent(newStatus) {
-    if (newStatus === "reconnecting") {
-      _connectionLossTimerId = setTimeout(() => {
-        batchUpdates(() => {
-          eventHub.lostConnection.notify("lost");
-          _hasLostConnection = true;
-          context.others.clearOthers();
-          notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
-        });
-      }, config.lostConnectionTimeout);
-    } else {
-      clearTimeout(_connectionLossTimerId);
-      if (_hasLostConnection) {
-        if (newStatus === "disconnected") {
-          batchUpdates(() => {
-            eventHub.lostConnection.notify("failed");
-          });
-        } else {
-          batchUpdates(() => {
-            eventHub.lostConnection.notify("restored");
-          });
-        }
-        _hasLostConnection = false;
-      }
-    }
-  }
-  function onDidConnect() {
-    context.buffer.presenceUpdates = {
-      type: "full",
-      data: (
-        // Because context.me.current is a readonly object, we'll have to
-        // make a copy here. Otherwise, type errors happen later when
-        // "patching" my presence.
-        { ...context.myPresence.current }
-      )
-    };
-    if (_getStorage$ !== null) {
-      refreshStorage({ flush: false });
-    }
-    flushNowOrSoon();
-  }
-  function onDidDisconnect() {
-    clearTimeout(context.buffer.flushTimerID);
+  function onDidDisconnect() {
+    clearTimeout(context.buffer.flushTimerID);
   }
   managedSocket.events.onMessage.subscribe(handleServerMessage);
   managedSocket.events.statusDidChange.subscribe(onStatusDidChange);
@@ -6592,16 +6329,411 @@ ${Array.from(traces).join("\n\n")}`
     ydoc: eventHub.ydoc.observable,
     comments: eventHub.comments.observable
   };
-  const commentsApi = createCommentsApi(
-    config.roomId,
-    delegates.authenticate,
-    fetchClientApi
-  );
-  async function fetchNotificationsJson(endpoint, options2) {
+  async function fetchCommentsApi(endpoint, params, options2) {
     const authValue = await delegates.authenticate();
-    const response = await fetchClientApi(
-      config.roomId,
-      endpoint,
+    return fetchClientApi(config.roomId, endpoint, authValue, options2, params);
+  }
+  async function fetchCommentsJson(endpoint, options2, params) {
+    const response = await fetchCommentsApi(endpoint, params, options2);
+    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;
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  async function getThreadsSince(options2) {
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        since: options2?.since?.toISOString()
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: {
+          updated: json.data.map(convertToThreadData),
+          deleted: json.deletedThreads.map(convertToThreadDeleteInfo)
+        },
+        inboxNotifications: {
+          updated: json.inboxNotifications.map(convertToInboxNotificationData),
+          deleted: json.deletedInboxNotifications.map(
+            convertToInboxNotificationDeleteInfo
+          )
+        },
+        requestedAt: new Date(json.meta.requestedAt)
+      };
+    } else if (response.status === 404) {
+      return {
+        threads: {
+          updated: [],
+          deleted: []
+        },
+        inboxNotifications: {
+          updated: [],
+          deleted: []
+        },
+        requestedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  async function getThreads(options2) {
+    let query;
+    if (options2?.query) {
+      query = objectToQuery(options2.query);
+    }
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        query
+      },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        threads: json.data.map(convertToThreadData),
+        inboxNotifications: json.inboxNotifications.map(
+          convertToInboxNotificationData
+        ),
+        requestedAt: new Date(json.meta.requestedAt)
+      };
+    } else if (response.status === 404) {
+      return {
+        threads: [],
+        inboxNotifications: [],
+        deletedThreads: [],
+        deletedInboxNotifications: [],
+        requestedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      throw new Error("There was an error while getting threads.");
+    }
+  }
+  async function getThread(threadId) {
+    const response = await fetchCommentsApi(
+      `/thread-with-notification/${threadId}`
+    );
+    if (response.ok) {
+      const json = await response.json();
+      return {
+        thread: convertToThreadData(json.thread),
+        inboxNotification: json.inboxNotification ? convertToInboxNotificationData(json.inboxNotification) : void 0
+      };
+    } else if (response.status === 404) {
+      return {
+        thread: void 0,
+        inboxNotification: void 0
+      };
+    } else {
+      throw new Error(`There was an error while getting thread ${threadId}.`);
+    }
+  }
+  async function createThread({
+    metadata,
+    body,
+    commentId = createCommentId(),
+    threadId = createThreadId(),
+    attachmentIds
+  }) {
+    const thread = await fetchCommentsJson("/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body,
+          attachmentIds
+        },
+        metadata
+      })
+    });
+    return convertToThreadData(thread);
+  }
+  async function deleteThread(threadId) {
+    await fetchCommentsJson(`/threads/${encodeURIComponent(threadId)}`, {
+      method: "DELETE"
+    });
+  }
+  async function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(metadata)
+      }
+    );
+  }
+  async function markThreadAsResolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-resolved`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  async function markThreadAsUnresolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-unresolved`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  async function createComment({
+    threadId,
+    commentId = createCommentId(),
+    body,
+    attachmentIds
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: commentId,
+          body,
+          attachmentIds
+        })
+      }
+    );
+    return convertToCommentData(comment);
+  }
+  async function editComment({
+    threadId,
+    commentId,
+    body,
+    attachmentIds
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body,
+          attachmentIds
+        })
+      }
+    );
+    return convertToCommentData(comment);
+  }
+  async function deleteComment2({
+    threadId,
+    commentId
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  async function addReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    const reaction = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ emoji })
+      }
+    );
+    return convertToCommentUserReaction(reaction);
+  }
+  async function removeReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  function prepareAttachment(file) {
+    return {
+      type: "localAttachment",
+      status: "idle",
+      id: createCommentAttachmentId(),
+      name: file.name,
+      size: file.size,
+      mimeType: file.type,
+      file
+    };
+  }
+  async function uploadAttachment(attachment, options2 = {}) {
+    const abortSignal = options2.signal;
+    const abortError = abortSignal ? new DOMException(
+      `Upload of attachment ${attachment.id} was aborted.`,
+      "AbortError"
+    ) : void 0;
+    if (abortSignal?.aborted) {
+      throw abortError;
+    }
+    if (attachment.size <= ATTACHMENT_PART_SIZE) {
+      return fetchCommentsJson(
+        `/attachments/${encodeURIComponent(attachment.id)}/upload/${encodeURIComponent(attachment.name)}`,
+        {
+          method: "PUT",
+          body: attachment.file,
+          signal: abortSignal
+        }
+      );
+    } else {
+      let uploadId;
+      const uploadedParts = [];
+      try {
+        const createMultiPartUpload = await fetchCommentsJson(
+          `/attachments/${encodeURIComponent(attachment.id)}/multipart/${encodeURIComponent(attachment.name)}`,
+          {
+            method: "POST",
+            signal: abortSignal
+          }
+        );
+        uploadId = createMultiPartUpload.uploadId;
+        const parts = splitFileIntoParts(attachment.file);
+        if (abortSignal?.aborted) {
+          throw abortError;
+        }
+        const batches = chunk(parts, ATTACHMENT_PART_BATCH_SIZE);
+        for (const parts2 of batches) {
+          const uploadedPartsPromises = [];
+          for (const { part, partNumber } of parts2) {
+            uploadedPartsPromises.push(
+              fetchCommentsJson(
+                `/attachments/${encodeURIComponent(attachment.id)}/multipart/${encodeURIComponent(uploadId)}/${encodeURIComponent(partNumber)}`,
+                {
+                  method: "PUT",
+                  body: part,
+                  signal: abortSignal
+                }
+              )
+            );
+          }
+          uploadedParts.push(...await Promise.all(uploadedPartsPromises));
+        }
+        if (abortSignal?.aborted) {
+          throw abortError;
+        }
+        const sortedUploadedParts = uploadedParts.sort(
+          (a, b) => a.partNumber - b.partNumber
+        );
+        return fetchCommentsJson(
+          `/attachments/${encodeURIComponent(attachment.id)}/multipart/${encodeURIComponent(uploadId)}/complete`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ parts: sortedUploadedParts }),
+            signal: abortSignal
+          }
+        );
+      } catch (error3) {
+        if (uploadId && error3?.name && (error3.name === "AbortError" || error3.name === "TimeoutError")) {
+          await fetchCommentsApi(
+            `/attachments/${encodeURIComponent(attachment.id)}/multipart/${encodeURIComponent(uploadId)}`,
+            void 0,
+            {
+              method: "DELETE"
+            }
+          );
+        }
+        throw error3;
+      }
+    }
+  }
+  async function getAttachmentUrls(attachmentIds) {
+    const { urls } = await fetchCommentsJson(
+      "/attachments/presigned-urls",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ attachmentIds })
+      }
+    );
+    return urls;
+  }
+  const batchedGetAttachmentUrls = new Batch(
+    async (batchedAttachmentIds) => {
+      const attachmentIds = batchedAttachmentIds.flat();
+      const attachmentUrls = await getAttachmentUrls(attachmentIds);
+      return attachmentUrls.map(
+        (url) => url ?? new Error("There was an error while getting this attachment's URL")
+      );
+    },
+    { delay: GET_ATTACHMENT_URLS_BATCH_DELAY }
+  );
+  const attachmentUrlsStore = createBatchStore(batchedGetAttachmentUrls);
+  function getAttachmentUrl(attachmentId) {
+    return batchedGetAttachmentUrls.get(attachmentId);
+  }
+  async function fetchNotificationsJson(endpoint, options2) {
+    const authValue = await delegates.authenticate();
+    const response = await fetchClientApi(
+      config.roomId,
+      endpoint,
       authValue,
       options2
     );
@@ -6706,7 +6838,8 @@ ${Array.from(traces).join("\n\n")}`
           // These exist only for our E2E testing app
           explicitClose: (event) => managedSocket._privateSendMachineEvent({ type: "EXPLICIT_SOCKET_CLOSE", event }),
           rawSend: (data) => managedSocket.send(data)
-        }
+        },
+        attachmentUrlsStore
       },
       id: config.roomId,
       subscribe: makeClassicSubscribeFn(events),
@@ -6747,10 +6880,27 @@ ${Array.from(traces).join("\n\n")}`
       // Presence
       getPresence: () => context.myPresence.current,
       getOthers: () => context.others.current,
+      // Comments
+      getThreads,
+      getThreadsSince,
+      getThread,
+      createThread,
+      deleteThread,
+      editThreadMetadata,
+      markThreadAsResolved,
+      markThreadAsUnresolved,
+      createComment,
+      editComment,
+      deleteComment: deleteComment2,
+      addReaction: addReaction2,
+      removeReaction: removeReaction2,
+      prepareAttachment,
+      uploadAttachment,
+      getAttachmentUrl,
+      // Notifications
       getNotificationSettings,
       updateNotificationSettings,
-      markInboxNotificationAsRead,
-      ...commentsApi
+      markInboxNotificationAsRead
     },
     // Explictly make the internal field non-enumerable, to avoid aggressive
     // freezing when used with Immer
@@ -7541,7 +7691,7 @@ function createClient(options) {
     () => !resolveUsers,
     "Set the resolveUsers option in createClient to specify user info."
   );
-  const usersStore = createBatchStore(
+  const batchedResolveUsers = new Batch(
     async (batchedUserIds) => {
       const userIds = batchedUserIds.flat();
       const users = await resolveUsers?.({ userIds });
@@ -7550,12 +7700,13 @@ function createClient(options) {
     },
     { delay: RESOLVE_USERS_BATCH_DELAY }
   );
+  const usersStore = createBatchStore(batchedResolveUsers);
   const resolveRoomsInfo = clientOptions.resolveRoomsInfo;
   const warnIfNoResolveRoomsInfo = createDevelopmentWarning(
     () => !resolveRoomsInfo,
     "Set the resolveRoomsInfo option in createClient to specify room info."
   );
-  const roomsInfoStore = createBatchStore(
+  const batchedResolveRoomsInfo = new Batch(
     async (batchedRoomIds) => {
       const roomIds = batchedRoomIds.flat();
       const roomsInfo = await resolveRoomsInfo?.({ roomIds });
@@ -7564,6 +7715,7 @@ function createClient(options) {
     },
     { delay: RESOLVE_ROOMS_INFO_BATCH_DELAY }
   );
+  const roomsInfoStore = createBatchStore(batchedResolveRoomsInfo);
   return Object.defineProperty(
     {
       enterRoom,
@@ -8469,6 +8621,7 @@ export {
   assert,
   assertNever,
   b64decode,
+  chunk,
   cloneLson,
   fancy_console_exports as console,
   convertToCommentData,