@liveblocks/core 2.9.3-experimental1 → 2.10.1-react19

package/dist/index.mjs

@@ -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 = "esm";
 
 // 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 = 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
         ...options?.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 {
-          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 {
+        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: options?.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: options?.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,14 +2384,12 @@ 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;
@@ -2212,7 +2397,7 @@ function createNotificationsApi({
       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),
@@ -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 (throwError?.(err) || err instanceof StopRetrying2) {
-        throw err;
-      }
-      if (attempt >= maxTries) {
-        throw new Error(`Failed after ${maxTries} attempts: ${String(err)}`);
-      }
-    }
-    const delay = 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,114 +5676,73 @@ 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 = config.polyfills?.fetch || /* istanbul ignore next */
-    fetch;
-    return await fetcher(url2, {
-      ...options2,
-      headers: {
-        ...options2?.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 = config.polyfills?.fetch || /* istanbul ignore next */
+  globalThis.fetch?.bind(globalThis);
+  const httpClient1 = new HttpClient(
+    config.baseUrl,
+    fetchPolyfill,
+    () => Promise.resolve(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);
@@ -5642,13 +5750,14 @@ function createRoom(options, config) {
     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"
         );
@@ -6252,10 +6361,10 @@ ${Array.from(traces).join("\n\n")}`
     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,76 +6573,25 @@ ${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 {
-          error3 = new CommentsApiError(response.statusText, response.status);
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = {};
-    }
-    return body;
-  }
   async function getThreadsSince(options2) {
-    const response = await fetchCommentsApi(
+    const result = await httpClient2.get(
       url`/v2/c/rooms/${config.roomId}/threads/delta`,
       { since: options2?.since?.toISOString() },
-      {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
+      { 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;
@@ -6541,40 +6599,22 @@ ${Array.from(traces).join("\n\n")}`
       query = objectToQuery(options2.query);
     }
     const PAGE_SIZE = 50;
-    const response = await fetchCommentsApi(
-      url`/v2/c/rooms/${config.roomId}/threads`,
-      {
-        cursor: options2?.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: options2?.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) {
@@ -6755,23 +6760,18 @@ ${Array.from(traces).join("\n\n")}`
       if (abortSignal?.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,
@@ -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,
@@ -6829,26 +6823,16 @@ ${Array.from(traces).join("\n\n")}`
         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 && error3?.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 {
-          error3 = new NotificationsApiError(
-            response.statusText,
-            response.status
-          );
-        }
-        throw error3;
-      }
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      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: options2?.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 })
       }
     );
@@ -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
@@ -7307,11 +7254,11 @@ function createClient(options) {
     }
   }
   const currentUserIdStore = createStore(null);
-  const fetcher = clientOptions.polyfills?.fetch || /* istanbul ignore next */
-  fetch;
-  const httpClientLike = createNotificationsApi({
+  const fetchPolyfill = clientOptions.polyfills?.fetch || /* istanbul ignore next */
+  globalThis.fetch?.bind(globalThis);
+  const notificationsAPI = createNotificationsApi({
     baseUrl,
-    fetcher,
+    fetchPolyfill,
     authManager,
     currentUserIdStore
   });
@@ -7330,6 +7277,9 @@ function createClient(options) {
     { delay: RESOLVE_USERS_BATCH_DELAY }
   );
   const usersStore = createBatchStore(batchedResolveUsers);
+  function invalidateResolvedUsers(userIds) {
+    usersStore.invalidate(userIds);
+  }
   const resolveRoomsInfo = clientOptions.resolveRoomsInfo;
   const warnIfNoResolveRoomsInfo = createDevelopmentWarning(
     () => !resolveRoomsInfo,
@@ -7345,15 +7295,29 @@ function createClient(options) {
     { 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(
@@ -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 = options?.maxStaleTimeMs ?? Number.POSITIVE_INFINITY;
+  const context = {
+    inForeground: doc?.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 = 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(doc?.visibilityState !== "hidden");
+  }
+  doc?.addEventListener("visibilitychange", onVisibilityChange);
+  win?.addEventListener("online", onVisibilityChange);
+  fsm.start();
   return {
-    enable
+    inc,
+    dec,
+    pollNowIfStale,
+    // Internal API, used by unit tests only to simulate visibility events
+    setInForeground
   };
 }
 
@@ -8177,19 +8193,92 @@ 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;
 export {
   ClientMsgCode,
   CommentsApiError,
   CrdtType,
+  HttpError,
   LiveList,
   LiveMap,
   LiveObject,
   NotificationsApiError,
   OpCode,
   ServerMsgCode,
-  StopRetrying2 as StopRetrying,
+  SortedList,
   WebsocketCloseCodes,
   ackOp,
   asPos,