@liveblocks/core 2.9.3-experimental1 → 2.10.1-react19

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.9.3-experimental1";
+var PKG_VERSION = "2.10.1-react19";
 var PKG_FORMAT = "cjs";
 
 // src/dupe-detection.ts
@@ -363,10 +363,39 @@ var FSM = class {
     this.enterFns.set(nameOrPattern, enterFn);
     return this;
   }
-  onEnterAsync(nameOrPattern, promiseFn, onOK, onError) {
+  /**
+   * Defines a promise-based state. When the state is entered, the promise is
+   * created. When the promise resolves, the machine will transition to the
+   * provided `onOK` target state. When the promise rejects, the machine will
+   * transition to the `onError` target state.
+   *
+   * Optionally, a `maxTimeout` can be set. If the timeout happens before the
+   * promise is settled, then the machine will also transition to the `onError`
+   * target state.
+   *
+   * @param stateOrPattern  The state name, or state group pattern name.
+   * @param promiseFn       The callback to be invoked when the state is entered.
+   * @param onOK            The state to transition to when the promise resolves.
+   * @param onError         The state to transition to when the promise
+   *                        rejects, or when the timeout happens before the
+   *                        promise has been settled.
+   * @param maxTimeout      Optional timeout in milliseconds.
+   *
+   * When the promise callback function is invoked, it's provided with an
+   * AbortSignal (2nd argument).
+   * If a state transition happens while the promise is pending (for example,
+   * an event, or a timeout happens), then an abort signal will be used to
+   * indicate this. Implementers can use this abort signal to terminate the
+   * in-flight promise, or ignore its results, etc.
+   */
+  onEnterAsync(nameOrPattern, promiseFn, onOK, onError, maxTimeout) {
     return this.onEnter(nameOrPattern, () => {
       const abortController = new AbortController();
       const signal = abortController.signal;
+      const timeoutId = maxTimeout ? setTimeout(() => {
+        const reason = new Error("Timed out");
+        this.transition({ type: "ASYNC_ERROR", reason }, onError);
+      }, maxTimeout) : void 0;
       let done = false;
       void promiseFn(this.currentContext.current, signal).then(
         // On OK
@@ -385,6 +414,7 @@ var FSM = class {
         }
       );
       return () => {
+        clearTimeout(timeoutId);
         if (!done) {
           abortController.abort();
         }
@@ -457,11 +487,11 @@ var FSM = class {
    * Like `.addTransition()`, but takes an (anonymous) transition whenever the
    * timer fires.
    *
-   * @param stateOrPattern The state name, or state group pattern name.
-   * @param after          Number of milliseconds after which to take the
-   *                       transition. If in the mean time, another transition
-   *                       is taken, the timer will get cancelled.
-   * @param target     The target state to go to.
+   * @param stateOrPattern  The state name, or state group pattern name.
+   * @param after           Number of milliseconds after which to take the
+   *                        transition. If in the mean time, another transition
+   *                        is taken, the timer will get cancelled.
+   * @param target          The target state to go to.
    */
   addTimedTransition(stateOrPattern, after2, target) {
     return this.onEnter(stateOrPattern, () => {
@@ -1520,8 +1550,8 @@ function prepareAuthentication(authOptions) {
     "Invalid Liveblocks client options. Please provide either a `publicApiKey` or `authEndpoint` option. They cannot both be empty. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
   );
 }
-async function fetchAuthEndpoint(fetch2, endpoint, body) {
-  const res = await fetch2(endpoint, {
+async function fetchAuthEndpoint(fetch, endpoint, body) {
+  const res = await fetch(endpoint, {
     method: "POST",
     headers: {
       "Content-Type": "application/json"
@@ -1881,6 +1911,16 @@ function createBatchStore(batch) {
     cache.set(cacheKey, state);
     eventSource2.notify();
   }
+  function invalidate(inputs) {
+    if (Array.isArray(inputs)) {
+      for (const input of inputs) {
+        cache.delete(getCacheKey(input));
+      }
+    } else {
+      cache.clear();
+    }
+    eventSource2.notify();
+  }
   async function get(input) {
     const cacheKey = getCacheKey(input);
     if (cache.has(cacheKey)) {
@@ -1901,10 +1941,15 @@ function createBatchStore(batch) {
     const cacheKey = getCacheKey(input);
     return cache.get(cacheKey);
   }
+  function _cacheKeys() {
+    return [...cache.keys()];
+  }
   return {
     ...eventSource2.observable,
     get,
-    getState
+    getState,
+    invalidate,
+    _cacheKeys
   };
 }
 
@@ -2044,12 +2089,36 @@ function convertToInboxNotificationDeleteInfo(data) {
   };
 }
 
-// src/http-client.ts
-function getBearerTokenFromAuthValue(authValue) {
-  if (authValue.type === "public") {
-    return authValue.publicApiKey;
-  } else {
-    return authValue.token.raw;
+// src/lib/autoRetry.ts
+var HttpError = class extends Error {
+  constructor(message, status, details) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.details = details;
+  }
+};
+var DONT_RETRY_4XX = (x) => x instanceof HttpError && x.status >= 400 && x.status < 500;
+async function autoRetry(promiseFn, maxTries, backoff, shouldStopRetrying = DONT_RETRY_4XX) {
+  const fallbackBackoff = backoff.length > 0 ? backoff[backoff.length - 1] : 0;
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    try {
+      return await promiseFn();
+    } catch (err) {
+      if (shouldStopRetrying(err)) {
+        throw err;
+      }
+      if (attempt >= maxTries) {
+        throw new Error(`Failed after ${maxTries} attempts: ${String(err)}`);
+      }
+    }
+    const delay = _nullishCoalesce(backoff[attempt - 1], () => ( fallbackBackoff));
+    warn(
+      `Attempt ${attempt} was unsuccessful. Retrying in ${delay} milliseconds.`
+    );
+    await wait(delay);
   }
 }
 
@@ -2076,51 +2145,79 @@ function url(strings, ...values) {
   );
 }
 
-// src/notifications.ts
-function createNotificationsApi({
-  baseUrl,
-  authManager,
-  currentUserIdStore,
-  fetcher
-}) {
-  async function fetchJson(endpoint, options, params) {
+// src/http-client.ts
+function getBearerTokenFromAuthValue(authValue) {
+  if (authValue.type === "public") {
+    return authValue.publicApiKey;
+  } else {
+    return authValue.token.raw;
+  }
+}
+var HttpClient = class {
+  constructor(baseUrl, fetchPolyfill, authCallback) {
+    this._baseUrl = baseUrl;
+    this._fetchPolyfill = fetchPolyfill;
+    this._authCallback = authCallback;
+  }
+  // ------------------------------------------------------------------
+  // Public methods
+  // ------------------------------------------------------------------
+  /**
+   * Constructs and makes the HTTP request, but does not handle the response.
+   *
+   * This is what .rawFetch() does:    👈 This method!
+   *   1. Set Content-Type header
+   *   2. Set Authorization header
+   *   3. Call the callback to obtain the `authValue` to use in the Authorization header
+   *
+   * This is what .fetch() does ON TOP of that:
+   *   4. Parse response body as Json
+   *   5. ...but silently return `{}` if that parsing fails
+   *   6. Throw HttpError if response is an error
+   */
+  async rawFetch(endpoint, options, params) {
     if (!endpoint.startsWith("/v2/c/")) {
-      raise("Expected a /v2/c/* endpoint");
-    }
-    const authValue = await authManager.getAuthValue({
-      requestedScope: "comments:read"
-    });
-    if (authValue.type === "secret" && authValue.token.parsed.k === "acc" /* ACCESS_TOKEN */) {
-      const userId = authValue.token.parsed.uid;
-      currentUserIdStore.set(() => userId);
+      raise("This client can only be used to make /v2/c/* requests");
     }
-    const url2 = urljoin(baseUrl, endpoint, params);
-    const response = await fetcher(url2.toString(), {
+    const url2 = urljoin(this._baseUrl, endpoint, params);
+    return await this._fetchPolyfill(url2, {
       ...options,
       headers: {
+        // These headers are default, but can be overriden by custom headers
+        "Content-Type": "application/json; charset=utf-8",
+        // Possible header overrides
         ..._optionalChain([options, 'optionalAccess', _45 => _45.headers]),
-        Authorization: `Bearer ${getBearerTokenFromAuthValue(authValue)}`,
+        // Cannot be overriden by custom headers
+        Authorization: `Bearer ${getBearerTokenFromAuthValue(await this._authCallback())}`,
         "X-LB-Client": PKG_VERSION || "dev"
       }
     });
+  }
+  /**
+   * Constructs, makes the HTTP request, and handles the response by parsing
+   * JSON and/or throwing an HttpError if it failed.
+   *
+   * This is what .rawFetch() does:
+   *   1. Set Content-Type header
+   *   2. Set Authorization header
+   *   3. Call the callback to obtain the `authValue` to use in the Authorization header
+   *
+   * This is what .fetch() does ON TOP of that:   👈 This method!
+   *   4. Parse response body as Json
+   *   5. ...but silently return `{}` if that parsing fails (🤔)
+   *   6. Throw HttpError if response is an error
+   */
+  async fetch(endpoint, options, params) {
+    const response = await this.rawFetch(endpoint, options, params);
     if (!response.ok) {
-      if (response.status >= 400 && response.status < 600) {
-        let error3;
-        try {
-          const errorBody = await response.json();
-          error3 = new NotificationsApiError(
-            errorBody.message,
-            response.status,
-            errorBody
-          );
-        } catch (e3) {
-          error3 = new NotificationsApiError(
-            response.statusText,
-            response.status
-          );
-        }
-        throw error3;
+      let error3;
+      try {
+        const errorBody = await response.json();
+        error3 = new HttpError(errorBody.message, response.status, errorBody);
+      } catch (e3) {
+        error3 = new HttpError(response.statusText, response.status);
       }
+      throw error3;
     }
     let body;
     try {
@@ -2130,9 +2227,103 @@ function createNotificationsApi({
     }
     return body;
   }
+  /**
+   * Makes a GET request and returns the raw response.
+   * Won't throw if the reponse is a non-2xx.
+   * @deprecated Ideally, use .get() instead.
+   */
+  async rawGet(endpoint, params, options) {
+    return await this.rawFetch(endpoint, options, params);
+  }
+  /**
+   * Makes a POST request and returns the raw response.
+   * Won't throw if the reponse is a non-2xx.
+   * @deprecated Ideally, use .post() instead.
+   */
+  async rawPost(endpoint, body) {
+    return await this.rawFetch(endpoint, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Makes a DELETE request and returns the raw response.
+   * Won't throw if the reponse is a non-2xx.
+   * @deprecated Ideally, use .delete() instead.
+   */
+  async rawDelete(endpoint) {
+    return await this.rawFetch(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Makes a GET request, and return the JSON response.
+   * Will throw if the reponse is a non-2xx.
+   */
+  async get(endpoint, params, options) {
+    return await this.fetch(endpoint, options, params);
+  }
+  /**
+   * Makes a POST request, and return the JSON response.
+   * Will throw if the reponse is a non-2xx.
+   */
+  async post(endpoint, body, options, params) {
+    return await this.fetch(
+      endpoint,
+      {
+        ...options,
+        method: "POST",
+        body: JSON.stringify(body)
+      },
+      params
+    );
+  }
+  /**
+   * Makes a DELETE request, and return the JSON response.
+   * Will throw if the reponse is a non-2xx.
+   */
+  async delete(endpoint) {
+    return await this.fetch(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Makes a PUT request for a Blob body, and return the JSON response.
+   * Will throw if the reponse is a non-2xx.
+   */
+  async putBlob(endpoint, blob, params, options) {
+    return await this.fetch(
+      endpoint,
+      {
+        ...options,
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/octet-stream"
+        },
+        body: blob
+      },
+      params
+    );
+  }
+};
+
+// src/notifications.ts
+function createNotificationsApi({
+  baseUrl,
+  authManager,
+  currentUserIdStore,
+  fetchPolyfill
+}) {
+  async function getAuthValue() {
+    const authValue = await authManager.getAuthValue({
+      requestedScope: "comments:read"
+    });
+    if (authValue.type === "secret" && authValue.token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+      const userId = authValue.token.parsed.uid;
+      currentUserIdStore.set(() => userId);
+    }
+    return authValue;
+  }
+  const httpClient = new HttpClient(baseUrl, fetchPolyfill, getAuthValue);
   async function getInboxNotifications(options) {
     const PAGE_SIZE = 50;
-    const json = await fetchJson(url`/v2/c/inbox-notifications`, void 0, {
+    const json = await httpClient.get(url`/v2/c/inbox-notifications`, {
       cursor: _optionalChain([options, 'optionalAccess', _46 => _46.cursor]),
       limit: PAGE_SIZE
     });
@@ -2145,10 +2336,12 @@ function createNotificationsApi({
       requestedAt: new Date(json.meta.requestedAt)
     };
   }
-  async function getInboxNotificationsSince(since) {
-    const json = await fetchJson(url`/v2/c/inbox-notifications/delta`, void 0, {
-      since: since.toISOString()
-    });
+  async function getInboxNotificationsSince(options) {
+    const json = await httpClient.get(
+      url`/v2/c/inbox-notifications/delta`,
+      { since: options.since.toISOString() },
+      { signal: _optionalChain([options, 'optionalAccess', _47 => _47.signal]) }
+    );
     return {
       inboxNotifications: {
         updated: json.inboxNotifications.map(convertToInboxNotificationData),
@@ -2164,25 +2357,19 @@ function createNotificationsApi({
     };
   }
   async function getUnreadInboxNotificationsCount() {
-    const { count } = await fetchJson(url`/v2/c/inbox-notifications/count`);
+    const { count } = await httpClient.get(
+      url`/v2/c/inbox-notifications/count`
+    );
     return count;
   }
   async function markAllInboxNotificationsAsRead() {
-    await fetchJson(url`/v2/c/inbox-notifications/read`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ inboxNotificationIds: "all" })
+    await httpClient.post(url`/v2/c/inbox-notifications/read`, {
+      inboxNotificationIds: "all"
     });
   }
   async function markInboxNotificationsAsRead(inboxNotificationIds) {
-    await fetchJson(url`/v2/c/inbox-notifications/read`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ inboxNotificationIds })
+    await httpClient.post(url`/v2/c/inbox-notifications/read`, {
+      inboxNotificationIds
     });
   }
   const batchedMarkInboxNotificationsAsRead = new Batch(
@@ -2197,22 +2384,20 @@ function createNotificationsApi({
     await batchedMarkInboxNotificationsAsRead.get(inboxNotificationId);
   }
   async function deleteAllInboxNotifications() {
-    await fetchJson(url`/v2/c/inbox-notifications`, {
-      method: "DELETE"
-    });
+    await httpClient.delete(url`/v2/c/inbox-notifications`);
   }
   async function deleteInboxNotification(inboxNotificationId) {
-    await fetchJson(url`/v2/c/inbox-notifications/${inboxNotificationId}`, {
-      method: "DELETE"
-    });
+    await httpClient.delete(
+      url`/v2/c/inbox-notifications/${inboxNotificationId}`
+    );
   }
   async function getUserThreads_experimental(options) {
     let query;
-    if (_optionalChain([options, 'optionalAccess', _47 => _47.query])) {
+    if (_optionalChain([options, 'optionalAccess', _48 => _48.query])) {
       query = objectToQuery(options.query);
     }
     const PAGE_SIZE = 50;
-    const json = await fetchJson(url`/v2/c/threads`, void 0, {
+    const json = await httpClient.get(url`/v2/c/threads`, {
       cursor: options.cursor,
       query,
       limit: PAGE_SIZE
@@ -2227,9 +2412,11 @@ function createNotificationsApi({
     };
   }
   async function getUserThreadsSince_experimental(options) {
-    const json = await fetchJson(url`/v2/c/threads/delta`, void 0, {
-      since: options.since.toISOString()
-    });
+    const json = await httpClient.get(
+      url`/v2/c/threads/delta`,
+      { since: options.since.toISOString() },
+      { signal: options.signal }
+    );
     return {
       threads: {
         updated: json.threads.map(convertToThreadData),
@@ -2626,7 +2813,7 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
     return [
       {
         type: 8 /* CREATE_REGISTER */,
-        opId: _optionalChain([pool, 'optionalAccess', _48 => _48.generateOpId, 'call', _49 => _49()]),
+        opId: _optionalChain([pool, 'optionalAccess', _49 => _49.generateOpId, 'call', _50 => _50()]),
         id: this._id,
         parentId,
         parentKey,
@@ -2728,7 +2915,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _50 => _50.generateOpId, 'call', _51 => _51()]),
+      opId: _optionalChain([pool, 'optionalAccess', _51 => _51.generateOpId, 'call', _52 => _52()]),
       type: 2 /* CREATE_LIST */,
       parentId,
       parentKey
@@ -3005,7 +3192,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applyInsertUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _52 => _52._pool, 'optionalAccess', _53 => _53.getNode, 'call', _54 => _54(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _53 => _53._pool, 'optionalAccess', _54 => _54.getNode, 'call', _55 => _55(id)]) !== void 0) {
       return { modified: false };
     }
     child._attach(id, nn(this._pool));
@@ -3013,8 +3200,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = _optionalChain([this, 'access', _55 => _55._items, 'access', _56 => _56[existingItemIndex], 'optionalAccess', _57 => _57._parentPos]);
-      const after2 = _optionalChain([this, 'access', _58 => _58._items, 'access', _59 => _59[existingItemIndex + 1], 'optionalAccess', _60 => _60._parentPos]);
+      const before2 = _optionalChain([this, 'access', _56 => _56._items, 'access', _57 => _57[existingItemIndex], 'optionalAccess', _58 => _58._parentPos]);
+      const after2 = _optionalChain([this, 'access', _59 => _59._items, 'access', _60 => _60[existingItemIndex + 1], 'optionalAccess', _61 => _61._parentPos]);
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
@@ -3029,7 +3216,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applySetUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _61 => _61._pool, 'optionalAccess', _62 => _62.getNode, 'call', _63 => _63(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _62 => _62._pool, 'optionalAccess', _63 => _63.getNode, 'call', _64 => _64(id)]) !== void 0) {
       return { modified: false };
     }
     this._unacknowledgedSets.set(key, nn(op.opId));
@@ -3151,7 +3338,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     } else {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _64 => _64._items, 'access', _65 => _65[existingItemIndex + 1], 'optionalAccess', _66 => _66._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _65 => _65._items, 'access', _66 => _66[existingItemIndex + 1], 'optionalAccess', _67 => _67._parentPos]))
       );
       const previousIndex = this._items.indexOf(child);
       child._setParentLink(this, newKey);
@@ -3177,7 +3364,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _67 => _67._items, 'access', _68 => _68[existingItemIndex + 1], 'optionalAccess', _69 => _69._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _68 => _68._items, 'access', _69 => _69[existingItemIndex + 1], 'optionalAccess', _70 => _70._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -3196,7 +3383,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _70 => _70._items, 'access', _71 => _71[existingItemIndex + 1], 'optionalAccess', _72 => _72._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _71 => _71._items, 'access', _72 => _72[existingItemIndex + 1], 'optionalAccess', _73 => _73._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -3224,7 +3411,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (existingItemIndex !== -1) {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _73 => _73._items, 'access', _74 => _74[existingItemIndex + 1], 'optionalAccess', _75 => _75._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _74 => _74._items, 'access', _75 => _75[existingItemIndex + 1], 'optionalAccess', _76 => _76._parentPos]))
       );
     }
     child._setParentLink(this, newKey);
@@ -3282,7 +3469,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    _optionalChain([this, 'access', _76 => _76._pool, 'optionalAccess', _77 => _77.assertStorageIsWritable, 'call', _78 => _78()]);
+    _optionalChain([this, 'access', _77 => _77._pool, 'optionalAccess', _78 => _78.assertStorageIsWritable, 'call', _79 => _79()]);
     return this.insert(element, this.length);
   }
   /**
@@ -3291,7 +3478,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
-    _optionalChain([this, 'access', _79 => _79._pool, 'optionalAccess', _80 => _80.assertStorageIsWritable, 'call', _81 => _81()]);
+    _optionalChain([this, 'access', _80 => _80._pool, 'optionalAccess', _81 => _81.assertStorageIsWritable, 'call', _82 => _82()]);
     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}`
@@ -3321,7 +3508,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param targetIndex The index where the element should be after moving.
    */
   move(index, targetIndex) {
-    _optionalChain([this, 'access', _82 => _82._pool, 'optionalAccess', _83 => _83.assertStorageIsWritable, 'call', _84 => _84()]);
+    _optionalChain([this, 'access', _83 => _83._pool, 'optionalAccess', _84 => _84.assertStorageIsWritable, 'call', _85 => _85()]);
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
@@ -3379,7 +3566,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index of the element to delete
    */
   delete(index) {
-    _optionalChain([this, 'access', _85 => _85._pool, 'optionalAccess', _86 => _86.assertStorageIsWritable, 'call', _87 => _87()]);
+    _optionalChain([this, 'access', _86 => _86._pool, 'optionalAccess', _87 => _87.assertStorageIsWritable, 'call', _88 => _88()]);
     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}`
@@ -3412,7 +3599,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   clear() {
-    _optionalChain([this, 'access', _88 => _88._pool, 'optionalAccess', _89 => _89.assertStorageIsWritable, 'call', _90 => _90()]);
+    _optionalChain([this, 'access', _89 => _89._pool, 'optionalAccess', _90 => _90.assertStorageIsWritable, 'call', _91 => _91()]);
     if (this._pool) {
       const ops = [];
       const reverseOps = [];
@@ -3446,7 +3633,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   set(index, item) {
-    _optionalChain([this, 'access', _91 => _91._pool, 'optionalAccess', _92 => _92.assertStorageIsWritable, 'call', _93 => _93()]);
+    _optionalChain([this, 'access', _92 => _92._pool, 'optionalAccess', _93 => _93.assertStorageIsWritable, 'call', _94 => _94()]);
     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}`
@@ -3594,7 +3781,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _shiftItemPosition(index, key) {
     const shiftedPosition = makePosition(
       key,
-      this._items.length > index + 1 ? _optionalChain([this, 'access', _94 => _94._items, 'access', _95 => _95[index + 1], 'optionalAccess', _96 => _96._parentPos]) : void 0
+      this._items.length > index + 1 ? _optionalChain([this, 'access', _95 => _95._items, 'access', _96 => _96[index + 1], 'optionalAccess', _97 => _97._parentPos]) : void 0
     );
     this._items[index]._setParentLink(this, shiftedPosition);
   }
@@ -3724,7 +3911,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _97 => _97.generateOpId, 'call', _98 => _98()]),
+      opId: _optionalChain([pool, 'optionalAccess', _98 => _98.generateOpId, 'call', _99 => _99()]),
       type: 7 /* CREATE_MAP */,
       parentId,
       parentKey
@@ -3871,7 +4058,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @param value The value of the element to add. Should be serializable to JSON.
    */
   set(key, value) {
-    _optionalChain([this, 'access', _99 => _99._pool, 'optionalAccess', _100 => _100.assertStorageIsWritable, 'call', _101 => _101()]);
+    _optionalChain([this, 'access', _100 => _100._pool, 'optionalAccess', _101 => _101.assertStorageIsWritable, 'call', _102 => _102()]);
     const oldValue = this._map.get(key);
     if (oldValue) {
       oldValue._detach();
@@ -3917,7 +4104,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @returns true if an element existed and has been removed, or false if the element does not exist.
    */
   delete(key) {
-    _optionalChain([this, 'access', _102 => _102._pool, 'optionalAccess', _103 => _103.assertStorageIsWritable, 'call', _104 => _104()]);
+    _optionalChain([this, 'access', _103 => _103._pool, 'optionalAccess', _104 => _104.assertStorageIsWritable, 'call', _105 => _105()]);
     const item = this._map.get(key);
     if (item === void 0) {
       return false;
@@ -4095,7 +4282,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
     }
-    const opId = _optionalChain([pool, 'optionalAccess', _105 => _105.generateOpId, 'call', _106 => _106()]);
+    const opId = _optionalChain([pool, 'optionalAccess', _106 => _106.generateOpId, 'call', _107 => _107()]);
     const ops = [];
     const op = {
       type: 4 /* CREATE_OBJECT */,
@@ -4373,7 +4560,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param value The value of the property to add
    */
   set(key, value) {
-    _optionalChain([this, 'access', _107 => _107._pool, 'optionalAccess', _108 => _108.assertStorageIsWritable, 'call', _109 => _109()]);
+    _optionalChain([this, 'access', _108 => _108._pool, 'optionalAccess', _109 => _109.assertStorageIsWritable, 'call', _110 => _110()]);
     this.update({ [key]: value });
   }
   /**
@@ -4388,7 +4575,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param key The key of the property to delete
    */
   delete(key) {
-    _optionalChain([this, 'access', _110 => _110._pool, 'optionalAccess', _111 => _111.assertStorageIsWritable, 'call', _112 => _112()]);
+    _optionalChain([this, 'access', _111 => _111._pool, 'optionalAccess', _112 => _112.assertStorageIsWritable, 'call', _113 => _113()]);
     const keyAsString = key;
     const oldValue = this._map.get(keyAsString);
     if (oldValue === void 0) {
@@ -4441,7 +4628,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param patch The object used to overrides properties
    */
   update(patch) {
-    _optionalChain([this, 'access', _113 => _113._pool, 'optionalAccess', _114 => _114.assertStorageIsWritable, 'call', _115 => _115()]);
+    _optionalChain([this, 'access', _114 => _114._pool, 'optionalAccess', _115 => _115.assertStorageIsWritable, 'call', _116 => _116()]);
     if (this._pool === void 0 || this._id === void 0) {
       for (const key in patch) {
         const newValue = patch[key];
@@ -4814,36 +5001,6 @@ function findNonSerializableValue(value, path = "") {
   return false;
 }
 
-// src/lib/autoRetry.ts
-async function autoRetry(promiseFn, maxTries, backoff, throwError) {
-  const fallbackBackoff = backoff.length > 0 ? backoff[backoff.length - 1] : 0;
-  let attempt = 0;
-  while (true) {
-    attempt++;
-    const promise = promiseFn();
-    try {
-      return await promise;
-    } catch (err) {
-      if (_optionalChain([throwError, 'optionalCall', _116 => _116(err)]) || err instanceof StopRetrying2) {
-        throw err;
-      }
-      if (attempt >= maxTries) {
-        throw new Error(`Failed after ${maxTries} attempts: ${String(err)}`);
-      }
-    }
-    const delay = _nullishCoalesce(backoff[attempt - 1], () => ( fallbackBackoff));
-    warn(
-      `Attempt ${attempt} was unsuccessful. Retrying in ${delay} milliseconds.`
-    );
-    await wait(delay);
-  }
-}
-var StopRetrying2 = class extends Error {
-  constructor(reason) {
-    super(reason);
-  }
-};
-
 // src/lib/chunk.ts
 function chunk(array, size) {
   const chunks = [];
@@ -5301,14 +5458,6 @@ function splitFileIntoParts(file) {
   }
   return parts;
 }
-var CommentsApiError = class extends Error {
-  constructor(message, status, details) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.details = details;
-  }
-};
 function createRoom(options, config) {
   const initialPresence = options.initialPresence;
   const initialStorage = options.initialStorage;
@@ -5527,128 +5676,88 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
-  async function fetchClientApi(endpoint, authValue, options2, params) {
-    if (!endpoint.startsWith("/v2/c/rooms/")) {
-      raise("Expected a /v2/c/rooms/* endpoint");
-    }
-    const url2 = urljoin(config.baseUrl, endpoint, params);
-    const fetcher = _optionalChain([config, 'access', _125 => _125.polyfills, 'optionalAccess', _126 => _126.fetch]) || /* istanbul ignore next */
-    fetch;
-    return await fetcher(url2, {
-      ...options2,
-      headers: {
-        ..._optionalChain([options2, 'optionalAccess', _127 => _127.headers]),
-        Authorization: `Bearer ${getBearerTokenFromAuthValue(authValue)}`,
-        "X-LB-Client": PKG_VERSION || "dev"
-      }
-    });
-  }
-  async function streamFetch(authValue, roomId) {
-    return fetchClientApi(url`/v2/c/rooms/${roomId}/storage`, authValue, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  }
-  async function httpPostToRoom(endpoint, body) {
-    if (!managedSocket.authValue) {
-      throw new Error("Not authorized");
-    }
-    return fetchClientApi(
-      endpoint === "/send-message" ? url`/v2/c/rooms/${config.roomId}/send-message` : url`/v2/c/rooms/${config.roomId}/text-metadata`,
-      managedSocket.authValue,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      }
-    );
-  }
+  const fetchPolyfill = _optionalChain([config, 'access', _125 => _125.polyfills, 'optionalAccess', _126 => _126.fetch]) || /* istanbul ignore next */
+  _optionalChain([globalThis, 'access', _127 => _127.fetch, 'optionalAccess', _128 => _128.bind, 'call', _129 => _129(globalThis)]);
+  const httpClient1 = new HttpClient(
+    config.baseUrl,
+    fetchPolyfill,
+    () => Promise.resolve(_nullishCoalesce(managedSocket.authValue, () => ( raise("Not authorized"))))
+  );
+  const httpClient2 = new HttpClient(
+    config.baseUrl,
+    fetchPolyfill,
+    () => (
+      // TODO: Use the right scope
+      delegates.authenticate()
+    )
+  );
   async function createTextMention(userId, mentionId) {
-    if (!managedSocket.authValue) {
-      throw new Error("Not authorized");
-    }
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/text-mentions`,
-      managedSocket.authValue,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          userId,
-          mentionId
-        })
-      }
-    );
+    await httpClient1.rawPost(url`/v2/c/rooms/${config.roomId}/text-mentions`, {
+      userId,
+      mentionId
+    });
   }
   async function deleteTextMention(mentionId) {
-    if (!managedSocket.authValue) {
-      throw new Error("Not authorized");
-    }
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/text-mentions/${mentionId}`,
-      managedSocket.authValue,
-      {
-        method: "DELETE"
-      }
+    await httpClient1.rawDelete(
+      url`/v2/c/rooms/${config.roomId}/text-mentions/${mentionId}`
     );
   }
   async function reportTextEditor(type, rootKey) {
-    const authValue = await delegates.authenticate();
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/text-metadata`,
-      authValue,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ type, rootKey })
-      }
-    );
+    await httpClient2.rawPost(url`/v2/c/rooms/${config.roomId}/text-metadata`, {
+      type,
+      rootKey
+    });
   }
   async function listTextVersions() {
-    const authValue = await delegates.authenticate();
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/versions`,
-      authValue,
-      {
-        method: "GET"
-      }
+    const result = await httpClient2.get(url`/v2/c/rooms/${config.roomId}/versions`);
+    return {
+      versions: result.versions.map(({ createdAt, ...version }) => {
+        return {
+          createdAt: new Date(createdAt),
+          ...version
+        };
+      }),
+      requestedAt: new Date(result.meta.requestedAt)
+    };
+  }
+  async function listTextVersionsSince(options2) {
+    const result = await httpClient2.get(
+      url`/v2/c/rooms/${config.roomId}/versions/delta`,
+      { since: options2.since.toISOString() },
+      { signal: options2.signal }
     );
+    return {
+      versions: result.versions.map(({ createdAt, ...version }) => {
+        return {
+          createdAt: new Date(createdAt),
+          ...version
+        };
+      }),
+      requestedAt: new Date(result.meta.requestedAt)
+    };
   }
   async function getTextVersion(versionId) {
-    const authValue = await delegates.authenticate();
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/y-version/${versionId}`,
-      authValue,
-      { method: "GET" }
+    return httpClient2.rawGet(
+      url`/v2/c/rooms/${config.roomId}/y-version/${versionId}`
     );
   }
   async function createTextVersion() {
-    const authValue = await delegates.authenticate();
-    return fetchClientApi(
-      url`/v2/c/rooms/${config.roomId}/version`,
-      authValue,
-      { method: "POST" }
-    );
+    await httpClient2.rawPost(url`/v2/c/rooms/${config.roomId}/version`);
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
-    const nonce = _optionalChain([context, 'access', _128 => _128.dynamicSessionInfo, 'access', _129 => _129.current, 'optionalAccess', _130 => _130.nonce]);
+    const nonce = _optionalChain([context, 'access', _130 => _130.dynamicSessionInfo, 'access', _131 => _131.current, 'optionalAccess', _132 => _132.nonce]);
     if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
-        void httpPostToRoom("/send-message", { nonce, messages }).then(
-          (resp) => {
-            if (!resp.ok && resp.status === 403) {
-              managedSocket.reconnect();
-            }
+        void httpClient1.rawPost(url`/v2/c/rooms/${config.roomId}/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"
         );
@@ -5700,7 +5809,7 @@ function createRoom(options, config) {
     } else {
       context.root = LiveObject._fromItems(message.items, pool);
     }
-    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _131 => _131.current, 'optionalAccess', _132 => _132.canWrite]), () => ( true));
+    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _133 => _133.current, 'optionalAccess', _134 => _134.canWrite]), () => ( true));
     const stackSizeBefore = context.undoStack.length;
     for (const key in context.initialStorage) {
       if (context.root.get(key) === void 0) {
@@ -5905,7 +6014,7 @@ function createRoom(options, config) {
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
-      if (_optionalChain([options2, 'optionalAccess', _133 => _133.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _135 => _135.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -5915,7 +6024,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _134 => _134.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _136 => _136.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -6113,7 +6222,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', _135 => _135.opStackTraces, 'optionalAccess', _136 => _136.get, 'call', _137 => _137(opId)]);
+                const trace = _optionalChain([context, 'access', _137 => _137.opStackTraces, 'optionalAccess', _138 => _138.get, 'call', _139 => _139(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -6247,15 +6356,15 @@ ${Array.from(traces).join("\n\n")}`
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(message, doNotBatchUpdates);
     applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-    _optionalChain([_resolveStoragePromise, 'optionalCall', _138 => _138()]);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _140 => _140()]);
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
   }
   async function streamStorage() {
-    if (!managedSocket.authValue) {
-      return;
-    }
-    const result = await streamFetch(managedSocket.authValue, config.roomId);
+    if (!managedSocket.authValue) return;
+    const result = await httpClient1.rawGet(
+      url`/v2/c/rooms/${config.roomId}/storage`
+    );
     const items = await result.json();
     processInitialStorage({ type: 200 /* INITIAL_STORAGE_STATE */, items });
   }
@@ -6464,117 +6573,48 @@ ${Array.from(traces).join("\n\n")}`
     ydoc: eventHub.ydoc.observable,
     comments: eventHub.comments.observable
   };
-  async function fetchCommentsApi(endpoint, params, options2) {
-    const authValue = await delegates.authenticate();
-    return fetchClientApi(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(
+    const result = await httpClient2.get(
       url`/v2/c/rooms/${config.roomId}/threads/delta`,
-      { since: _optionalChain([options2, 'optionalAccess', _139 => _139.since, 'optionalAccess', _140 => _140.toISOString, 'call', _141 => _141()]) },
-      {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
+      { since: _optionalChain([options2, 'optionalAccess', _141 => _141.since, 'optionalAccess', _142 => _142.toISOString, 'call', _143 => _143()]) },
+      { signal: options2.signal }
     );
-    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.");
-    }
+    return {
+      threads: {
+        updated: result.data.map(convertToThreadData),
+        deleted: result.deletedThreads.map(convertToThreadDeleteInfo)
+      },
+      inboxNotifications: {
+        updated: result.inboxNotifications.map(convertToInboxNotificationData),
+        deleted: result.deletedInboxNotifications.map(
+          convertToInboxNotificationDeleteInfo
+        )
+      },
+      requestedAt: new Date(result.meta.requestedAt)
+    };
   }
   async function getThreads(options2) {
     let query;
-    if (_optionalChain([options2, 'optionalAccess', _142 => _142.query])) {
+    if (_optionalChain([options2, 'optionalAccess', _144 => _144.query])) {
       query = objectToQuery(options2.query);
     }
     const PAGE_SIZE = 50;
-    const response = await fetchCommentsApi(
-      url`/v2/c/rooms/${config.roomId}/threads`,
-      {
-        cursor: _optionalChain([options2, 'optionalAccess', _143 => _143.cursor]),
-        query,
-        limit: PAGE_SIZE
-      },
-      { headers: { "Content-Type": "application/json" } }
-    );
-    if (response.ok) {
-      const json = await response.json();
-      return {
-        threads: json.data.map(convertToThreadData),
-        inboxNotifications: json.inboxNotifications.map(
-          convertToInboxNotificationData
-        ),
-        nextCursor: json.meta.nextCursor,
-        requestedAt: new Date(json.meta.requestedAt)
-      };
-    } else if (response.status === 404) {
-      return {
-        threads: [],
-        inboxNotifications: [],
-        deletedThreads: [],
-        deletedInboxNotifications: [],
-        nextCursor: null,
-        requestedAt: /* @__PURE__ */ new Date()
-      };
-    } else {
-      throw new Error("There was an error while getting threads.");
-    }
+    const result = await httpClient2.get(url`/v2/c/rooms/${config.roomId}/threads`, {
+      cursor: _optionalChain([options2, 'optionalAccess', _145 => _145.cursor]),
+      query,
+      limit: PAGE_SIZE
+    });
+    return {
+      threads: result.data.map(convertToThreadData),
+      inboxNotifications: result.inboxNotifications.map(
+        convertToInboxNotificationData
+      ),
+      nextCursor: result.meta.nextCursor,
+      requestedAt: new Date(result.meta.requestedAt)
+    };
   }
   async function getThread(threadId) {
-    const response = await fetchCommentsApi(
+    const response = await httpClient2.rawGet(
       url`/v2/c/rooms/${config.roomId}/thread-with-notification/${threadId}`
     );
     if (response.ok) {
@@ -6599,57 +6639,42 @@ ${Array.from(traces).join("\n\n")}`
     threadId = createThreadId(),
     attachmentIds
   }) {
-    const thread = await fetchCommentsJson(
+    const thread = await httpClient2.post(
       url`/v2/c/rooms/${config.roomId}/threads`,
       {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
+        id: threadId,
+        comment: {
+          id: commentId,
+          body,
+          attachmentIds
         },
-        body: JSON.stringify({
-          id: threadId,
-          comment: {
-            id: commentId,
-            body,
-            attachmentIds
-          },
-          metadata
-        })
+        metadata
       }
     );
     return convertToThreadData(thread);
   }
   async function deleteThread(threadId) {
-    await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/threads/${threadId}`,
-      { method: "DELETE" }
+    await httpClient2.delete(
+      url`/v2/c/rooms/${config.roomId}/threads/${threadId}`
     );
   }
   async function editThreadMetadata({
     metadata,
     threadId
   }) {
-    return await fetchCommentsJson(
+    return await httpClient2.post(
       url`/v2/c/rooms/${config.roomId}/threads/${threadId}/metadata`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(metadata)
-      }
+      metadata
     );
   }
   async function markThreadAsResolved(threadId) {
-    await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/mark-as-resolved`,
-      { method: "POST" }
+    await httpClient2.post(
+      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/mark-as-resolved`
     );
   }
   async function markThreadAsUnresolved(threadId) {
-    await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/mark-as-unresolved`,
-      { method: "POST" }
+    await httpClient2.post(
+      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/mark-as-unresolved`
     );
   }
   async function createComment({
@@ -6658,18 +6683,12 @@ ${Array.from(traces).join("\n\n")}`
     body,
     attachmentIds
   }) {
-    const comment = await fetchCommentsJson(
+    const comment = await httpClient2.post(
       url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments`,
       {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: commentId,
-          body,
-          attachmentIds
-        })
+        id: commentId,
+        body,
+        attachmentIds
       }
     );
     return convertToCommentData(comment);
@@ -6680,17 +6699,11 @@ ${Array.from(traces).join("\n\n")}`
     body,
     attachmentIds
   }) {
-    const comment = await fetchCommentsJson(
+    const comment = await httpClient2.post(
       url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}`,
       {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          body,
-          attachmentIds
-        })
+        body,
+        attachmentIds
       }
     );
     return convertToCommentData(comment);
@@ -6699,9 +6712,8 @@ ${Array.from(traces).join("\n\n")}`
     threadId,
     commentId
   }) {
-    await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}`,
-      { method: "DELETE" }
+    await httpClient2.delete(
+      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}`
     );
   }
   async function addReaction({
@@ -6709,15 +6721,9 @@ ${Array.from(traces).join("\n\n")}`
     commentId,
     emoji
   }) {
-    const reaction = await fetchCommentsJson(
+    const reaction = await httpClient2.post(
       url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}/reactions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ emoji })
-      }
+      { emoji }
     );
     return convertToCommentUserReaction(reaction);
   }
@@ -6726,9 +6732,8 @@ ${Array.from(traces).join("\n\n")}`
     commentId,
     emoji
   }) {
-    await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}/reactions/${emoji}`,
-      { method: "DELETE" }
+    await httpClient2.delete(
+      url`/v2/c/rooms/${config.roomId}/threads/${threadId}/comments/${commentId}/reactions/${emoji}`
     );
   }
   function prepareAttachment(file) {
@@ -6748,30 +6753,25 @@ ${Array.from(traces).join("\n\n")}`
       `Upload of attachment ${attachment.id} was aborted.`,
       "AbortError"
     ) : void 0;
-    if (_optionalChain([abortSignal, 'optionalAccess', _144 => _144.aborted])) {
+    if (_optionalChain([abortSignal, 'optionalAccess', _146 => _146.aborted])) {
       throw abortError;
     }
     const handleRetryError = (err) => {
-      if (_optionalChain([abortSignal, 'optionalAccess', _145 => _145.aborted])) {
+      if (_optionalChain([abortSignal, 'optionalAccess', _147 => _147.aborted])) {
         throw abortError;
       }
-      if (err instanceof CommentsApiError && err.status === 413) {
+      if (err instanceof HttpError && err.status === 413) {
         throw err;
       }
       return false;
     };
     if (attachment.size <= ATTACHMENT_PART_SIZE) {
       return autoRetry(
-        () => fetchCommentsJson(
+        () => httpClient2.putBlob(
           url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/upload/${encodeURIComponent(attachment.name)}`,
-          {
-            method: "PUT",
-            body: attachment.file,
-            signal: abortSignal
-          },
-          {
-            fileSize: attachment.size
-          }
+          attachment.file,
+          { fileSize: attachment.size },
+          { signal: abortSignal }
         ),
         RETRY_ATTEMPTS,
         RETRY_DELAYS,
@@ -6781,15 +6781,11 @@ ${Array.from(traces).join("\n\n")}`
       let uploadId;
       const uploadedParts = [];
       const createMultiPartUpload = await autoRetry(
-        () => fetchCommentsJson(
+        () => httpClient2.post(
           url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/multipart/${encodeURIComponent(attachment.name)}`,
-          {
-            method: "POST",
-            signal: abortSignal
-          },
-          {
-            fileSize: attachment.size
-          }
+          void 0,
+          { signal: abortSignal },
+          { fileSize: attachment.size }
         ),
         RETRY_ATTEMPTS,
         RETRY_DELAYS,
@@ -6798,7 +6794,7 @@ ${Array.from(traces).join("\n\n")}`
       try {
         uploadId = createMultiPartUpload.uploadId;
         const parts = splitFileIntoParts(attachment.file);
-        if (_optionalChain([abortSignal, 'optionalAccess', _146 => _146.aborted])) {
+        if (_optionalChain([abortSignal, 'optionalAccess', _148 => _148.aborted])) {
           throw abortError;
         }
         const batches = chunk(parts, ATTACHMENT_PART_BATCH_SIZE);
@@ -6807,13 +6803,11 @@ ${Array.from(traces).join("\n\n")}`
           for (const { part, partNumber } of parts2) {
             uploadedPartsPromises.push(
               autoRetry(
-                () => fetchCommentsJson(
+                () => httpClient2.putBlob(
                   url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/multipart/${createMultiPartUpload.uploadId}/${String(partNumber)}`,
-                  {
-                    method: "PUT",
-                    body: part,
-                    signal: abortSignal
-                  }
+                  part,
+                  void 0,
+                  { signal: abortSignal }
                 ),
                 RETRY_ATTEMPTS,
                 RETRY_DELAYS,
@@ -6823,32 +6817,22 @@ ${Array.from(traces).join("\n\n")}`
           }
           uploadedParts.push(...await Promise.all(uploadedPartsPromises));
         }
-        if (_optionalChain([abortSignal, 'optionalAccess', _147 => _147.aborted])) {
+        if (_optionalChain([abortSignal, 'optionalAccess', _149 => _149.aborted])) {
           throw abortError;
         }
         const sortedUploadedParts = uploadedParts.sort(
           (a, b) => a.partNumber - b.partNumber
         );
-        return fetchCommentsJson(
+        return httpClient2.post(
           url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/multipart/${uploadId}/complete`,
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({ parts: sortedUploadedParts }),
-            signal: abortSignal
-          }
+          { parts: sortedUploadedParts },
+          { signal: abortSignal }
         );
       } catch (error3) {
-        if (uploadId && _optionalChain([error3, 'optionalAccess', _148 => _148.name]) && (error3.name === "AbortError" || error3.name === "TimeoutError")) {
+        if (uploadId && _optionalChain([error3, 'optionalAccess', _150 => _150.name]) && (error3.name === "AbortError" || error3.name === "TimeoutError")) {
           try {
-            await fetchCommentsApi(
-              url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/multipart/${uploadId}`,
-              void 0,
-              {
-                method: "DELETE"
-              }
+            await httpClient2.rawDelete(
+              url`/v2/c/rooms/${config.roomId}/attachments/${attachment.id}/multipart/${uploadId}`
             );
           } catch (error4) {
           }
@@ -6858,16 +6842,9 @@ ${Array.from(traces).join("\n\n")}`
     }
   }
   async function getAttachmentUrls(attachmentIds) {
-    const { urls } = await fetchCommentsJson(
-      url`/v2/c/rooms/${config.roomId}/attachments/presigned-urls`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ attachmentIds })
-      }
-    );
+    const { urls } = await httpClient2.post(url`/v2/c/rooms/${config.roomId}/attachments/presigned-urls`, {
+      attachmentIds
+    });
     return urls;
   }
   const batchedGetAttachmentUrls = new Batch(
@@ -6885,38 +6862,12 @@ ${Array.from(traces).join("\n\n")}`
     return batchedGetAttachmentUrls.get(attachmentId);
   }
   async function fetchNotificationsJson(endpoint, options2) {
-    const authValue = await delegates.authenticate();
-    const response = await fetchClientApi(endpoint, authValue, options2);
-    if (!response.ok) {
-      if (response.status >= 400 && response.status < 600) {
-        let error3;
-        try {
-          const errorBody = await response.json();
-          error3 = new NotificationsApiError(
-            errorBody.message,
-            response.status,
-            errorBody
-          );
-        } catch (e7) {
-          error3 = new NotificationsApiError(
-            response.statusText,
-            response.status
-          );
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch (e8) {
-      body = {};
-    }
-    return body;
+    return await httpClient2.get(endpoint, void 0, options2);
   }
-  function getNotificationSettings() {
+  function getNotificationSettings(options2) {
     return fetchNotificationsJson(
-      url`/v2/c/rooms/${config.roomId}/notification-settings`
+      url`/v2/c/rooms/${config.roomId}/notification-settings`,
+      { signal: _optionalChain([options2, 'optionalAccess', _151 => _151.signal]) }
     );
   }
   function updateNotificationSettings(settings) {
@@ -6924,10 +6875,7 @@ ${Array.from(traces).join("\n\n")}`
       url`/v2/c/rooms/${config.roomId}/notification-settings`,
       {
         method: "POST",
-        body: JSON.stringify(settings),
-        headers: {
-          "Content-Type": "application/json"
-        }
+        body: JSON.stringify(settings)
       }
     );
   }
@@ -6936,9 +6884,6 @@ ${Array.from(traces).join("\n\n")}`
       url`/v2/c/rooms/${config.roomId}/inbox-notifications/read`,
       {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
         body: JSON.stringify({ inboxNotificationIds })
       }
     );
@@ -6958,7 +6903,7 @@ ${Array.from(traces).join("\n\n")}`
     {
       [kInternal]: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _149 => _149.buffer, 'access', _150 => _150.presenceUpdates, 'optionalAccess', _151 => _151.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _152 => _152.buffer, 'access', _153 => _153.presenceUpdates, 'optionalAccess', _154 => _154.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -6985,6 +6930,8 @@ ${Array.from(traces).join("\n\n")}`
         deleteTextMention,
         // list versions of the document
         listTextVersions,
+        // List versions of the document since the specified date
+        listTextVersionsSince,
         // get a specific version
         getTextVersion,
         // create a version
@@ -7142,7 +7089,7 @@ function makeClassicSubscribeFn(events) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _152 => _152.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _155 => _155.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -7262,12 +7209,12 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             baseUrl,
-            _optionalChain([clientOptions, 'access', _153 => _153.polyfills, 'optionalAccess', _154 => _154.WebSocket])
+            _optionalChain([clientOptions, 'access', _156 => _156.polyfills, 'optionalAccess', _157 => _157.WebSocket])
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         })),
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _155 => _155.unstable_batchedUpdates]),
+        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _158 => _158.unstable_batchedUpdates]),
         baseUrl,
         unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP,
         unstable_streamData: !!clientOptions.unstable_streamData
@@ -7283,7 +7230,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.autoConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _156 => _156.polyfills, 'optionalAccess', _157 => _157.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _159 => _159.polyfills, 'optionalAccess', _160 => _160.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"
           );
@@ -7295,7 +7242,7 @@ function createClient(options) {
     return leaseRoom(newRoomDetails);
   }
   function getRoom(roomId) {
-    const room = _optionalChain([roomsById, 'access', _158 => _158.get, 'call', _159 => _159(roomId), 'optionalAccess', _160 => _160.room]);
+    const room = _optionalChain([roomsById, 'access', _161 => _161.get, 'call', _162 => _162(roomId), 'optionalAccess', _163 => _163.room]);
     return room ? room : null;
   }
   function logout() {
@@ -7307,11 +7254,11 @@ function createClient(options) {
     }
   }
   const currentUserIdStore = createStore(null);
-  const fetcher = _optionalChain([clientOptions, 'access', _161 => _161.polyfills, 'optionalAccess', _162 => _162.fetch]) || /* istanbul ignore next */
-  fetch;
-  const httpClientLike = createNotificationsApi({
+  const fetchPolyfill = _optionalChain([clientOptions, 'access', _164 => _164.polyfills, 'optionalAccess', _165 => _165.fetch]) || /* istanbul ignore next */
+  _optionalChain([globalThis, 'access', _166 => _166.fetch, 'optionalAccess', _167 => _167.bind, 'call', _168 => _168(globalThis)]);
+  const notificationsAPI = createNotificationsApi({
     baseUrl,
-    fetcher,
+    fetchPolyfill,
     authManager,
     currentUserIdStore
   });
@@ -7323,13 +7270,16 @@ function createClient(options) {
   const batchedResolveUsers = new Batch(
     async (batchedUserIds) => {
       const userIds = batchedUserIds.flat();
-      const users = await _optionalChain([resolveUsers, 'optionalCall', _163 => _163({ userIds })]);
+      const users = await _optionalChain([resolveUsers, 'optionalCall', _169 => _169({ userIds })]);
       warnIfNoResolveUsers();
       return _nullishCoalesce(users, () => ( userIds.map(() => void 0)));
     },
     { delay: RESOLVE_USERS_BATCH_DELAY }
   );
   const usersStore = createBatchStore(batchedResolveUsers);
+  function invalidateResolvedUsers(userIds) {
+    usersStore.invalidate(userIds);
+  }
   const resolveRoomsInfo = clientOptions.resolveRoomsInfo;
   const warnIfNoResolveRoomsInfo = createDevelopmentWarning(
     () => !resolveRoomsInfo,
@@ -7338,22 +7288,36 @@ function createClient(options) {
   const batchedResolveRoomsInfo = new Batch(
     async (batchedRoomIds) => {
       const roomIds = batchedRoomIds.flat();
-      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _164 => _164({ roomIds })]);
+      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _170 => _170({ roomIds })]);
       warnIfNoResolveRoomsInfo();
       return _nullishCoalesce(roomsInfo, () => ( roomIds.map(() => void 0)));
     },
     { delay: RESOLVE_ROOMS_INFO_BATCH_DELAY }
   );
   const roomsInfoStore = createBatchStore(batchedResolveRoomsInfo);
-  return Object.defineProperty(
+  function invalidateResolvedRoomsInfo(roomIds) {
+    roomsInfoStore.invalidate(roomIds);
+  }
+  const mentionSuggestionsCache = /* @__PURE__ */ new Map();
+  function invalidateResolvedMentionSuggestions() {
+    mentionSuggestionsCache.clear();
+  }
+  const client = Object.defineProperty(
     {
       enterRoom,
       getRoom,
       logout,
-      ...httpClientLike,
+      ...notificationsAPI,
+      // Advanced resolvers APIs
+      resolvers: {
+        invalidateUsers: invalidateResolvedUsers,
+        invalidateRoomsInfo: invalidateResolvedRoomsInfo,
+        invalidateMentionSuggestions: invalidateResolvedMentionSuggestions
+      },
       // Internal
       [kInternal]: {
         currentUserIdStore,
+        mentionSuggestionsCache,
         resolveMentionSuggestions: clientOptions.resolveMentionSuggestions,
         usersStore,
         roomsInfoStore,
@@ -7361,8 +7325,10 @@ function createClient(options) {
           return Array.from(roomsById.keys());
         },
         // "All" threads (= "user" threads)
-        getUserThreads_experimental: httpClientLike.getUserThreads_experimental,
-        getUserThreadsSince_experimental: httpClientLike.getUserThreadsSince_experimental
+        getUserThreads_experimental: notificationsAPI.getUserThreads_experimental,
+        getUserThreadsSince_experimental: notificationsAPI.getUserThreadsSince_experimental,
+        // Type-level helper only, it's effectively only an identity-function at runtime
+        as: () => client
       }
     },
     kInternal,
@@ -7370,15 +7336,8 @@ function createClient(options) {
       enumerable: false
     }
   );
+  return client;
 }
-var NotificationsApiError = class extends Error {
-  constructor(message, status, details) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.details = details;
-  }
-};
 function checkBounds(option, value, min, max, recommendedMin) {
   if (typeof value !== "number" || value < min || max !== void 0 && value > max) {
     throw new Error(
@@ -7448,7 +7407,7 @@ var commentBodyElementsTypes = {
   mention: "inline"
 };
 function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
-  if (!body || !_optionalChain([body, 'optionalAccess', _165 => _165.content])) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _171 => _171.content])) {
     return;
   }
   const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
@@ -7458,13 +7417,13 @@ function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
   for (const block of body.content) {
     if (type === "all" || type === "block") {
       if (guard(block)) {
-        _optionalChain([visitor, 'optionalCall', _166 => _166(block)]);
+        _optionalChain([visitor, 'optionalCall', _172 => _172(block)]);
       }
     }
     if (type === "all" || type === "inline") {
       for (const inline of block.children) {
         if (guard(inline)) {
-          _optionalChain([visitor, 'optionalCall', _167 => _167(inline)]);
+          _optionalChain([visitor, 'optionalCall', _173 => _173(inline)]);
         }
       }
     }
@@ -7489,7 +7448,7 @@ async function resolveUsersInCommentBody(body, resolveUsers) {
     userIds
   });
   for (const [index, userId] of userIds.entries()) {
-    const user = _optionalChain([users, 'optionalAccess', _168 => _168[index]]);
+    const user = _optionalChain([users, 'optionalAccess', _174 => _174[index]]);
     if (user) {
       resolvedUsers.set(userId, user);
     }
@@ -7612,7 +7571,7 @@ var stringifyCommentBodyPlainElements = {
   text: ({ element }) => element.text,
   link: ({ element }) => _nullishCoalesce(element.text, () => ( element.url)),
   mention: ({ element, user }) => {
-    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _169 => _169.name]), () => ( element.id))}`;
+    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _175 => _175.name]), () => ( element.id))}`;
   }
 };
 var stringifyCommentBodyHtmlElements = {
@@ -7642,7 +7601,7 @@ var stringifyCommentBodyHtmlElements = {
     return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${_nullishCoalesce(element.text, () => ( element.url))}</a>`;
   },
   mention: ({ element, user }) => {
-    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _170 => _170.name]), () => ( element.id))}</span>`;
+    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _176 => _176.name]), () => ( element.id))}</span>`;
   }
 };
 var stringifyCommentBodyMarkdownElements = {
@@ -7672,19 +7631,19 @@ var stringifyCommentBodyMarkdownElements = {
     return markdown`[${_nullishCoalesce(element.text, () => ( element.url))}](${href})`;
   },
   mention: ({ element, user }) => {
-    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _171 => _171.name]), () => ( element.id))}`;
+    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _177 => _177.name]), () => ( element.id))}`;
   }
 };
 async function stringifyCommentBody(body, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _172 => _172.format]), () => ( "plain"));
-  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _173 => _173.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _178 => _178.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _179 => _179.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
   const elements = {
     ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ..._optionalChain([options, 'optionalAccess', _174 => _174.elements])
+    ..._optionalChain([options, 'optionalAccess', _180 => _180.elements])
   };
   const resolvedUsers = await resolveUsersInCommentBody(
     body,
-    _optionalChain([options, 'optionalAccess', _175 => _175.resolveUsers])
+    _optionalChain([options, 'optionalAccess', _181 => _181.resolveUsers])
   );
   const blocks = body.content.flatMap((block, blockIndex) => {
     switch (block.type) {
@@ -7959,12 +7918,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _176 => _176.updates, 'access', _177 => _177[key], 'optionalAccess', _178 => _178.type]) === "update") {
+          if (_optionalChain([update, 'access', _182 => _182.updates, 'access', _183 => _183[key], 'optionalAccess', _184 => _184.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _179 => _179.updates, 'access', _180 => _180[key], 'optionalAccess', _181 => _181.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _185 => _185.updates, 'access', _186 => _186[key], 'optionalAccess', _187 => _187.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -8025,12 +7984,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _182 => _182.updates, 'access', _183 => _183[key], 'optionalAccess', _184 => _184.type]) === "update") {
+          if (_optionalChain([update, 'access', _188 => _188.updates, 'access', _189 => _189[key], 'optionalAccess', _190 => _190.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _185 => _185.updates, 'access', _186 => _186[key], 'optionalAccess', _187 => _187.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _191 => _191.updates, 'access', _192 => _192[key], 'optionalAccess', _193 => _193.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -8096,45 +8055,102 @@ function errorIf(condition, message) {
 }
 
 // src/lib/Poller.ts
-function makePoller(callback, interval) {
-  let context = { state: "stopped" };
-  function poll() {
-    if (context.state === "running") {
-      schedule();
-    }
-    void callback();
-  }
-  function schedule() {
-    context = {
-      state: "running",
-      lastScheduledAt: performance.now(),
-      timeoutHandle: setTimeout(poll, interval)
-    };
-  }
-  function start() {
-    if (context.state === "running") {
-      return;
+var BACKOFF_DELAYS2 = [1e3, 2e3, 4e3, 8e3, 1e4];
+function makePoller(callback, intervalMs, options) {
+  const startTime = performance.now();
+  const doc = typeof document !== "undefined" ? document : void 0;
+  const win = typeof window !== "undefined" ? window : void 0;
+  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _194 => _194.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
+  const context = {
+    inForeground: _optionalChain([doc, 'optionalAccess', _195 => _195.visibilityState]) !== "hidden",
+    lastSuccessfulPollAt: startTime,
+    count: 0,
+    backoff: 0
+  };
+  function mayPoll() {
+    return context.count > 0 && context.inForeground;
+  }
+  const fsm = new FSM({}).addState("@idle").addState("@enabled").addState("@polling");
+  fsm.addTransitions("@idle", { START: "@enabled" });
+  fsm.addTransitions("@enabled", { STOP: "@idle", POLL: "@polling" });
+  fsm.addTimedTransition(
+    "@enabled",
+    () => {
+      const lastPoll = context.lastSuccessfulPollAt;
+      const nextPoll = lastPoll + intervalMs;
+      return Math.max(0, nextPoll - performance.now()) + context.backoff;
+    },
+    "@polling"
+  );
+  fsm.onEnterAsync(
+    "@polling",
+    async (_ctx, signal) => {
+      await callback(signal);
+      if (!signal.aborted) {
+        context.lastSuccessfulPollAt = performance.now();
+      }
+    },
+    // When OK
+    () => {
+      return {
+        target: mayPoll() ? "@enabled" : "@idle",
+        effect: () => {
+          context.backoff = 0;
+        }
+      };
+    },
+    // When error
+    () => {
+      return {
+        target: mayPoll() ? "@enabled" : "@idle",
+        effect: () => {
+          context.backoff = _nullishCoalesce(BACKOFF_DELAYS2.find((delay) => delay > context.backoff), () => ( BACKOFF_DELAYS2[BACKOFF_DELAYS2.length - 1]));
+        }
+      };
+    },
+    3e4
+    // Abort the poll if the callback takes more than 30 seconds to complete
+  );
+  function startOrStop() {
+    if (mayPoll()) {
+      fsm.send({ type: "START" });
+    } else {
+      fsm.send({ type: "STOP" });
     }
-    schedule();
   }
-  function stop() {
-    if (context.state === "stopped") {
-      return;
-    }
-    if (context.timeoutHandle) {
-      clearTimeout(context.timeoutHandle);
+  function inc() {
+    context.count++;
+    startOrStop();
+  }
+  function dec() {
+    context.count--;
+    if (context.count < 0) {
+      context.count = 0;
     }
-    context = { state: "stopped" };
+    startOrStop();
   }
-  function enable(condition) {
-    if (condition) {
-      start();
-    } else {
-      stop();
+  function pollNowIfStale() {
+    if (performance.now() - context.lastSuccessfulPollAt > maxStaleTimeMs) {
+      fsm.send({ type: "POLL" });
     }
   }
+  function setInForeground(inForeground) {
+    context.inForeground = inForeground;
+    startOrStop();
+    pollNowIfStale();
+  }
+  function onVisibilityChange() {
+    setInForeground(_optionalChain([doc, 'optionalAccess', _196 => _196.visibilityState]) !== "hidden");
+  }
+  _optionalChain([doc, 'optionalAccess', _197 => _197.addEventListener, 'call', _198 => _198("visibilitychange", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _199 => _199.addEventListener, 'call', _200 => _200("online", onVisibilityChange)]);
+  fsm.start();
   return {
-    enable
+    inc,
+    dec,
+    pollNowIfStale,
+    // Internal API, used by unit tests only to simulate visibility events
+    setInForeground
   };
 }
 
@@ -8177,8 +8193,81 @@ function shallow(a, b) {
   return shallowObj(a, b);
 }
 
+// src/lib/SortedList.ts
+function bisectRight(arr, x, lt) {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + (hi - lo >> 1);
+    if (lt(x, arr[mid])) {
+      hi = mid;
+    } else {
+      lo = mid + 1;
+    }
+  }
+  return lo;
+}
+var SortedList = class _SortedList {
+  constructor(alreadySortedList, lt) {
+    this._lt = lt;
+    this._data = alreadySortedList;
+  }
+  static from(arr, lt) {
+    const sorted = new _SortedList([], lt);
+    for (const item of arr) {
+      sorted.add(item);
+    }
+    return sorted;
+  }
+  static fromAlreadySorted(alreadySorted, lt) {
+    return new _SortedList(alreadySorted, lt);
+  }
+  /**
+   * Clones the sorted list to a new instance.
+   */
+  clone() {
+    return new _SortedList(this._data.slice(), this._lt);
+  }
+  /**
+   * Adds a new item to the sorted list, such that it remains sorted.
+   */
+  add(value) {
+    const idx = bisectRight(this._data, value, this._lt);
+    this._data.splice(idx, 0, value);
+  }
+  /**
+   * Removes the given value from the sorted list, if it exists. The given
+   * value must be `===` to one of the list items. Only the first entry will be
+   * removed if the element exists in the sorted list multiple times.
+   */
+  remove(value) {
+    const idx = this._data.indexOf(value);
+    if (idx >= 0) {
+      this._data.splice(idx, 1);
+      return true;
+    }
+    return false;
+  }
+  get length() {
+    return this._data.length;
+  }
+  *filter(predicate) {
+    for (const item of this._data) {
+      if (predicate(item)) {
+        yield item;
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    return this._data[Symbol.iterator]();
+  }
+};
+
 // src/index.ts
 detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
+var CommentsApiError = HttpError;
+var NotificationsApiError = HttpError;
+
 
 
 
@@ -8246,5 +8335,5 @@ detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 
 
 
-exports.ClientMsgCode = ClientMsgCode; exports.CommentsApiError = CommentsApiError; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.NotificationsApiError = NotificationsApiError; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.StopRetrying = StopRetrying2; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.ackOp = ackOp; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.autoRetry = autoRetry; exports.b64decode = b64decode; exports.chunk = chunk; exports.cloneLson = cloneLson; exports.compactObject = compactObject; exports.console = fancy_console_exports; exports.convertToCommentData = convertToCommentData; exports.convertToCommentUserReaction = convertToCommentUserReaction; exports.convertToInboxNotificationData = convertToInboxNotificationData; exports.convertToThreadData = convertToThreadData; exports.createClient = createClient; exports.createCommentId = createCommentId; exports.createInboxNotificationId = createInboxNotificationId; exports.createStore = createStore; exports.createThreadId = createThreadId; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.getMentionedIdsFromCommentBody = getMentionedIdsFromCommentBody; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isLiveNode = isLiveNode; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.kInternal = kInternal; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makeEventSource = makeEventSource; exports.makePoller = makePoller; exports.makePosition = makePosition; exports.mapValues = mapValues; exports.memoizeOnSuccess = memoizeOnSuccess; exports.nanoid = nanoid; exports.nn = nn; exports.objectToQuery = objectToQuery; exports.patchLiveObjectKey = patchLiveObjectKey; exports.raise = raise; exports.shallow = shallow; exports.stringify = stringify; exports.stringifyCommentBody = stringifyCommentBody; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.url = url; exports.urljoin = urljoin; exports.wait = wait; exports.withTimeout = withTimeout;
+exports.ClientMsgCode = ClientMsgCode; exports.CommentsApiError = CommentsApiError; exports.CrdtType = CrdtType; exports.HttpError = HttpError; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.NotificationsApiError = NotificationsApiError; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.SortedList = SortedList; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.ackOp = ackOp; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.autoRetry = autoRetry; exports.b64decode = b64decode; exports.chunk = chunk; exports.cloneLson = cloneLson; exports.compactObject = compactObject; exports.console = fancy_console_exports; exports.convertToCommentData = convertToCommentData; exports.convertToCommentUserReaction = convertToCommentUserReaction; exports.convertToInboxNotificationData = convertToInboxNotificationData; exports.convertToThreadData = convertToThreadData; exports.createClient = createClient; exports.createCommentId = createCommentId; exports.createInboxNotificationId = createInboxNotificationId; exports.createStore = createStore; exports.createThreadId = createThreadId; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.getMentionedIdsFromCommentBody = getMentionedIdsFromCommentBody; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isLiveNode = isLiveNode; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.kInternal = kInternal; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makeEventSource = makeEventSource; exports.makePoller = makePoller; exports.makePosition = makePosition; exports.mapValues = mapValues; exports.memoizeOnSuccess = memoizeOnSuccess; exports.nanoid = nanoid; exports.nn = nn; exports.objectToQuery = objectToQuery; exports.patchLiveObjectKey = patchLiveObjectKey; exports.raise = raise; exports.shallow = shallow; exports.stringify = stringify; exports.stringifyCommentBody = stringifyCommentBody; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.url = url; exports.urljoin = urljoin; exports.wait = wait; exports.withTimeout = withTimeout;
 //# sourceMappingURL=index.js.map