@liveblocks/core 2.5.1 → 2.6.0

package/dist/index.js

@@ -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.6.0";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -5172,297 +5172,6 @@ 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 (e5) {
-          error3 = new CommentsApiError(response.statusText, response.status);
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch (e6) {
-      body = {};
-    }
-    return body;
-  }
-  async function getThreadsSince(options) {
-    const response = await fetchCommentsApi(
-      "/threads",
-      {
-        since: _optionalChain([options, 'optionalAccess', _119 => _119.since, 'optionalAccess', _120 => _120.toISOString, 'call', _121 => _121()])
-      },
-      {
-        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(options) {
-    let query;
-    if (_optionalChain([options, 'optionalAccess', _122 => _122.query])) {
-      query = objectToQuery(options.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()
-  }) {
-    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;
@@ -5654,7 +5363,7 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      const scopes = _optionalChain([context, 'access', _123 => _123.dynamicSessionInfo, 'access', _124 => _124.current, 'optionalAccess', _125 => _125.scopes]);
+      const scopes = _optionalChain([context, 'access', _119 => _119.dynamicSessionInfo, 'access', _120 => _120.current, 'optionalAccess', _121 => _121.scopes]);
       if (scopes === void 0) {
         return;
       }
@@ -5688,12 +5397,12 @@ function createRoom(options, config) {
       `/v2/c/rooms/${encodeURIComponent(roomId)}${endpoint}`,
       params
     );
-    const fetcher = _optionalChain([config, 'access', _126 => _126.polyfills, 'optionalAccess', _127 => _127.fetch]) || /* istanbul ignore next */
+    const fetcher = _optionalChain([config, 'access', _122 => _122.polyfills, 'optionalAccess', _123 => _123.fetch]) || /* istanbul ignore next */
     fetch;
     return await fetcher(url, {
       ...options2,
       headers: {
-        ..._optionalChain([options2, 'optionalAccess', _128 => _128.headers]),
+        ..._optionalChain([options2, 'optionalAccess', _124 => _124.headers]),
         Authorization: `Bearer ${getAuthBearerHeaderFromAuthValue(authValue)}`
       }
     });
@@ -5766,7 +5475,7 @@ function createRoom(options, config) {
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
-    const nonce = _optionalChain([context, 'access', _129 => _129.dynamicSessionInfo, 'access', _130 => _130.current, 'optionalAccess', _131 => _131.nonce]);
+    const nonce = _optionalChain([context, 'access', _125 => _125.dynamicSessionInfo, 'access', _126 => _126.current, 'optionalAccess', _127 => _127.nonce]);
     if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
@@ -5828,7 +5537,7 @@ function createRoom(options, config) {
     } else {
       context.root = LiveObject._fromItems(message.items, pool);
     }
-    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _132 => _132.current, 'optionalAccess', _133 => _133.canWrite]), () => ( true));
+    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _128 => _128.current, 'optionalAccess', _129 => _129.canWrite]), () => ( true));
     const stackSizeBefore = context.undoStack.length;
     for (const key in context.initialStorage) {
       if (context.root.get(key) === void 0) {
@@ -6033,7 +5742,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _134 => _134.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _130 => _130.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -6043,7 +5752,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _135 => _135.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _131 => _131.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -6241,7 +5950,7 @@ function createRoom(options, config) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = _optionalChain([context, 'access', _136 => _136.opStackTraces, 'optionalAccess', _137 => _137.get, 'call', _138 => _138(opId)]);
+                const trace = _optionalChain([context, 'access', _132 => _132.opStackTraces, 'optionalAccess', _133 => _133.get, 'call', _134 => _134(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -6375,7 +6084,7 @@ ${Array.from(traces).join("\n\n")}`
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(message, doNotBatchUpdates);
     applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-    _optionalChain([_resolveStoragePromise, 'optionalCall', _139 => _139()]);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _135 => _135()]);
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
   }
@@ -6466,137 +6175,406 @@ ${Array.from(traces).join("\n\n")}`
     if (context.activeBatch) {
       throw new Error("redo is not allowed during a batch");
     }
-    const historyOps = context.redoStack.pop();
-    if (historyOps === void 0) {
-      return;
+    const historyOps = context.redoStack.pop();
+    if (historyOps === void 0) {
+      return;
+    }
+    context.pausedHistory = null;
+    const result = applyOps(historyOps, true);
+    batchUpdates(() => {
+      notify(result.updates, doNotBatchUpdates);
+      context.undoStack.push(result.reverse);
+      onHistoryChange(doNotBatchUpdates);
+    });
+    for (const op of result.ops) {
+      if (op.type !== "presence") {
+        context.buffer.storageOperations.push(op);
+      }
+    }
+    flushNowOrSoon();
+  }
+  function clear() {
+    context.undoStack.length = 0;
+    context.redoStack.length = 0;
+  }
+  function batch(callback) {
+    if (context.activeBatch) {
+      return callback();
+    }
+    let returnValue = void 0;
+    batchUpdates(() => {
+      context.activeBatch = {
+        ops: [],
+        updates: {
+          storageUpdates: /* @__PURE__ */ new Map(),
+          presence: false,
+          others: []
+        },
+        reverseOps: []
+      };
+      try {
+        returnValue = callback();
+      } finally {
+        const currentBatch = context.activeBatch;
+        context.activeBatch = null;
+        if (currentBatch.reverseOps.length > 0) {
+          addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
+        }
+        if (currentBatch.ops.length > 0) {
+          context.redoStack.length = 0;
+        }
+        if (currentBatch.ops.length > 0) {
+          dispatchOps(currentBatch.ops);
+        }
+        notify(currentBatch.updates, doNotBatchUpdates);
+        flushNowOrSoon();
+      }
+    });
+    return returnValue;
+  }
+  function pauseHistory() {
+    if (context.pausedHistory === null) {
+      context.pausedHistory = [];
+    }
+  }
+  function resumeHistory() {
+    const historyOps = context.pausedHistory;
+    context.pausedHistory = null;
+    if (historyOps !== null && historyOps.length > 0) {
+      _addToRealUndoStack(historyOps, batchUpdates);
+    }
+  }
+  function getStorageStatus() {
+    if (context.root === void 0) {
+      return _getStorage$ === null ? "not-loaded" : "loading";
+    } else {
+      return context.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
+    }
+  }
+  let _lastStorageStatus = getStorageStatus();
+  function notifyStorageStatus() {
+    const storageStatus = getStorageStatus();
+    if (_lastStorageStatus !== storageStatus) {
+      _lastStorageStatus = storageStatus;
+      eventHub.storageStatus.notify(storageStatus);
+    }
+  }
+  function isPresenceReady() {
+    return self.current !== null;
+  }
+  async function waitUntilPresenceReady() {
+    while (!isPresenceReady()) {
+      const { promise, resolve } = Promise_withResolvers();
+      const unsub1 = events.self.subscribeOnce(resolve);
+      const unsub2 = events.status.subscribeOnce(resolve);
+      await promise;
+      unsub1();
+      unsub2();
+    }
+  }
+  function isStorageReady() {
+    return getStorageSnapshot() !== null;
+  }
+  async function waitUntilStorageReady() {
+    while (!isStorageReady()) {
+      await getStorage();
+    }
+  }
+  const others_forDevTools = new DerivedRef(
+    context.others,
+    (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
+  );
+  const events = {
+    status: eventHub.status.observable,
+    lostConnection: eventHub.lostConnection.observable,
+    customEvent: eventHub.customEvent.observable,
+    others: eventHub.others.observable,
+    self: eventHub.self.observable,
+    myPresence: eventHub.myPresence.observable,
+    error: eventHub.error.observable,
+    /** @deprecated */
+    storage: eventHub.storageBatch.observable,
+    storageBatch: eventHub.storageBatch.observable,
+    history: eventHub.history.observable,
+    storageDidLoad: eventHub.storageDidLoad.observable,
+    storageStatus: eventHub.storageStatus.observable,
+    ydoc: eventHub.ydoc.observable,
+    comments: eventHub.comments.observable
+  };
+  async function fetchCommentsApi(endpoint, params, options2) {
+    const authValue = await delegates.authenticate();
+    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 (e5) {
+          error3 = new CommentsApiError(response.statusText, response.status);
+        }
+        throw error3;
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch (e6) {
+      body = {};
+    }
+    return body;
+  }
+  async function getThreadsSince(options2) {
+    const response = await fetchCommentsApi(
+      "/threads",
+      {
+        since: _optionalChain([options2, 'optionalAccess', _136 => _136.since, 'optionalAccess', _137 => _137.toISOString, 'call', _138 => _138()])
+      },
+      {
+        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 (_optionalChain([options2, 'optionalAccess', _139 => _139.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}.`);
     }
-    context.pausedHistory = null;
-    const result = applyOps(historyOps, true);
-    batchUpdates(() => {
-      notify(result.updates, doNotBatchUpdates);
-      context.undoStack.push(result.reverse);
-      onHistoryChange(doNotBatchUpdates);
+  }
+  async function createThread({
+    metadata,
+    body,
+    commentId = createCommentId(),
+    threadId = createThreadId()
+  }) {
+    const thread = await fetchCommentsJson("/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body
+        },
+        metadata
+      })
     });
-    for (const op of result.ops) {
-      if (op.type !== "presence") {
-        context.buffer.storageOperations.push(op);
-      }
-    }
-    flushNowOrSoon();
+    return convertToThreadData(thread);
   }
-  function clear() {
-    context.undoStack.length = 0;
-    context.redoStack.length = 0;
+  async function deleteThread(threadId) {
+    await fetchCommentsJson(`/threads/${encodeURIComponent(threadId)}`, {
+      method: "DELETE"
+    });
   }
-  function batch(callback) {
-    if (context.activeBatch) {
-      return callback();
-    }
-    let returnValue = void 0;
-    batchUpdates(() => {
-      context.activeBatch = {
-        ops: [],
-        updates: {
-          storageUpdates: /* @__PURE__ */ new Map(),
-          presence: false,
-          others: []
+  async function editThreadMetadata({
+    metadata,
+    threadId
+  }) {
+    return await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        reverseOps: []
-      };
-      try {
-        returnValue = callback();
-      } finally {
-        const currentBatch = context.activeBatch;
-        context.activeBatch = null;
-        if (currentBatch.reverseOps.length > 0) {
-          addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
-        }
-        if (currentBatch.ops.length > 0) {
-          context.redoStack.length = 0;
-        }
-        if (currentBatch.ops.length > 0) {
-          dispatchOps(currentBatch.ops);
-        }
-        notify(currentBatch.updates, doNotBatchUpdates);
-        flushNowOrSoon();
+        body: JSON.stringify(metadata)
       }
-    });
-    return returnValue;
-  }
-  function pauseHistory() {
-    if (context.pausedHistory === null) {
-      context.pausedHistory = [];
-    }
+    );
   }
-  function resumeHistory() {
-    const historyOps = context.pausedHistory;
-    context.pausedHistory = null;
-    if (historyOps !== null && historyOps.length > 0) {
-      _addToRealUndoStack(historyOps, batchUpdates);
-    }
+  async function markThreadAsResolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-resolved`,
+      {
+        method: "POST"
+      }
+    );
   }
-  function getStorageStatus() {
-    if (context.root === void 0) {
-      return _getStorage$ === null ? "not-loaded" : "loading";
-    } else {
-      return context.unacknowledgedOps.size === 0 ? "synchronized" : "synchronizing";
-    }
+  async function markThreadAsUnresolved(threadId) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/mark-as-unresolved`,
+      {
+        method: "POST"
+      }
+    );
   }
-  let _lastStorageStatus = getStorageStatus();
-  function notifyStorageStatus() {
-    const storageStatus = getStorageStatus();
-    if (_lastStorageStatus !== storageStatus) {
-      _lastStorageStatus = storageStatus;
-      eventHub.storageStatus.notify(storageStatus);
-    }
+  async function createComment({
+    threadId,
+    commentId = createCommentId(),
+    body
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: commentId,
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
   }
-  function isPresenceReady() {
-    return self.current !== null;
+  async function editComment({
+    threadId,
+    commentId,
+    body
+  }) {
+    const comment = await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body
+        })
+      }
+    );
+    return convertToCommentData(comment);
   }
-  async function waitUntilPresenceReady() {
-    while (!isPresenceReady()) {
-      const { promise, resolve } = Promise_withResolvers();
-      const unsub1 = events.self.subscribeOnce(resolve);
-      const unsub2 = events.status.subscribeOnce(resolve);
-      await promise;
-      unsub1();
-      unsub2();
-    }
+  async function deleteComment2({
+    threadId,
+    commentId
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
-  function isStorageReady() {
-    return getStorageSnapshot() !== null;
+  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 waitUntilStorageReady() {
-    while (!isStorageReady()) {
-      await getStorage();
-    }
+  async function removeReaction2({
+    threadId,
+    commentId,
+    emoji
+  }) {
+    await fetchCommentsJson(
+      `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
+        commentId
+      )}/reactions/${encodeURIComponent(emoji)}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
-  const others_forDevTools = new DerivedRef(
-    context.others,
-    (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
-  );
-  const events = {
-    status: eventHub.status.observable,
-    lostConnection: eventHub.lostConnection.observable,
-    customEvent: eventHub.customEvent.observable,
-    others: eventHub.others.observable,
-    self: eventHub.self.observable,
-    myPresence: eventHub.myPresence.observable,
-    error: eventHub.error.observable,
-    /** @deprecated */
-    storage: eventHub.storageBatch.observable,
-    storageBatch: eventHub.storageBatch.observable,
-    history: eventHub.history.observable,
-    storageDidLoad: eventHub.storageDidLoad.observable,
-    storageStatus: eventHub.storageStatus.observable,
-    ydoc: eventHub.ydoc.observable,
-    comments: eventHub.comments.observable
-  };
-  const commentsApi = createCommentsApi(
-    config.roomId,
-    delegates.authenticate,
-    fetchClientApi
-  );
   async function fetchNotificationsJson(endpoint, options2) {
     const authValue = await delegates.authenticate();
     const response = await fetchClientApi(
@@ -6747,10 +6725,24 @@ ${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,
+      // Notifications
       getNotificationSettings,
       updateNotificationSettings,
-      markInboxNotificationAsRead,
-      ...commentsApi
+      markInboxNotificationAsRead
     },
     // Explictly make the internal field non-enumerable, to avoid aggressive
     // freezing when used with Immer