stream-chat 10.0.0-rc.16 → 10.0.0-rc.17

package/dist/cjs/index.browser.js

@@ -266,7 +266,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client.ts
-var import_axios4 = __toESM(require("axios"));
+var import_axios5 = __toESM(require("axios"));
 
 // src/gen/models/index.ts
 var ChannelOwnCapability = {
@@ -7744,6 +7744,9 @@ function isErrorRetryable(error) {
   if (!err) return false;
   return err.retryable;
 }
+function isConnectionIDError(error) {
+  return error.code === 46;
+}
 function isEphemeral(error) {
   if ((0, import_axios2.isCancel)(error)) return false;
   if (!error.response) return true;
@@ -17847,6 +17850,7 @@ var runWithRetry = (f, {
 // src/api-client.ts
 var logger9 = chatLoggerSystem.getLogger("api-client");
 var MULTIPART_CONTENT_TYPE = "multipart/form-data";
+var LONG_POLL_PATH = "/api/v2/longpoll";
 var UPLOAD_REQUEST_DEFAULTS = {
   timeout: 0,
   maxContentLength: Infinity,
@@ -17867,8 +17871,8 @@ var ApiClient = class {
       params: queryParams,
       headers: { "Content-Type": requestContentType },
       ...isMultipart ? UPLOAD_REQUEST_DEFAULTS : {},
-      // Keep this last so a caller-supplied signal wins - and keep it returning only the keys
-      // it owns, so it can never clobber the upload defaults above.
+      // Keep this last so a caller-supplied signal and timeout win - and keep it returning only
+      // the keys it owns, so it can never clobber the upload defaults above.
       ...toAxiosRequestConfig(options)
     });
   }
@@ -17899,7 +17903,11 @@ var ApiClient = class {
       }
     }
     if (resolved.startsWith("/")) {
-      resolved = this.client.baseURL + resolved;
+      const baseURL = resolved === LONG_POLL_PATH ? (
+        // replace port if present for testing with local API
+        this.client.baseURL?.replace(":3030", ":8900")
+      ) : this.client.baseURL;
+      resolved = baseURL + resolved;
     }
     return resolved;
   }
@@ -17953,6 +17961,7 @@ var ApiClient = class {
         params: { ...additionalConfig.params, connection_id: connectionId }
       };
     }
+    await this.client.tokenManager.tokenReady();
     const initialRequestConfig = this.populateRequestConfigWithDefaults(additionalConfig);
     const clientRequestId = initialRequestConfig.headers?.["x-client-request-id"];
     try {
@@ -18014,25 +18023,23 @@ var ApiClient = class {
 var requiresConnectionId = (params, body) => {
   const payload = params?.payload;
   const requestBody = typeof body === "object" && body !== null ? body : void 0;
-  if (params?.watch || params?.presence || payload?.watch || payload?.presence || requestBody?.watch || requestBody?.presence) {
-    return true;
-  }
-  if ([params, payload, requestBody].some(
-    (source) => source && ("watch" in source || "presence" in source)
-  )) {
-    return false;
-  }
-  return Boolean(params && "connection_id" in params);
+  return Boolean(
+    params?.watch || params?.presence || payload?.watch || payload?.presence || requestBody?.watch || requestBody?.presence
+  );
 };
 var isUsableAbortSignal = (signal) => typeof signal?.addEventListener === "function";
 var toAxiosRequestConfig = ({
   signal,
-  onUploadProgress
+  onUploadProgress,
+  timeout
 } = {}) => ({
   signal: isUsableAbortSignal(signal) ? signal : void 0,
   // Same reasoning as `isUsableAbortSignal`: an options object revived from a persisted
   // offline-db task payload has lost its functions.
-  onUploadProgress: typeof onUploadProgress === "function" ? onUploadProgress : void 0
+  onUploadProgress: typeof onUploadProgress === "function" ? onUploadProgress : void 0,
+  // Only when set: an explicit `undefined` would clobber the upload defaults' `timeout: 0`, and
+  // axios would fall back to the instance timeout.
+  ...typeof timeout === "number" ? { timeout } : {}
 });
 var errorIsApiError = (error) => {
   if (!(error instanceof import_axios3.AxiosError)) return false;
@@ -20580,6 +20587,16 @@ var NetworkConnectionObserver = class extends WithSubscriptions {
   get isOnline() {
     return this.state.getLatestValue().isOnline;
   }
+  /**
+   * Whether the installed reporter is the host default that mirrors this client's WebSocket
+   * (`createWSConnectionNetworkStatusReporter`). Under it `isOnline === false` means "the socket is
+   * down", not "the device is offline".
+   *
+   * @internal
+   */
+  get usesDefaultWSConnectionNetworkStatusReporter() {
+    return this.installedReporter !== void 0 && this.installedReporter === this.defaultReporter && this.defaultReporter !== browserNetworkStatusReporter;
+  }
   /**
    * Installs the platform listener that reports device network status, unsubscribing whatever was
    * there. Pass `null` to clear it, which leaves the last known status alone rather than reverting to
@@ -20631,6 +20648,7 @@ var NetworkConnectionObserver = class extends WithSubscriptions {
 // src/connection/wsConnection/config.ts
 var DEFAULT_WS_CONNECTION_CONFIG = deepFreezeConfig({
   connectTimeoutMs: 15 * 1e3,
+  enableWSFallback: false,
   pingIntervalMs: 25 * 1e3,
   healthCheckGracePeriodMs: 10 * 1e3,
   offlineNotificationDisplayDelayMs: 5 * 1e3,
@@ -21218,7 +21236,190 @@ var StableWSConnection = class {
 
 // src/connection/wsConnection/WSConnection.ts
 var import_state_store25 = require("@stream-io/state-store");
-var logger15 = chatLoggerSystem.getLogger("client");
+
+// src/connection/wsConnection/WSConnectionFallback.ts
+var import_axios4 = __toESM(require("axios"));
+var logger15 = chatLoggerSystem.getLogger("connection");
+var WSConnectionFallback = class {
+  constructor({ client }) {
+    /**
+     * Applies a change in the device's network status. Stands in for v9's `window` online/offline
+     * listeners: `WSConnection` routes the network-status store here once it has switched to this
+     * long-poll.
+     *
+     * @internal
+     */
+    this._applyNetworkStatus = (online) => {
+      if (this.state === "DISCONNECTED" /* Disconnected */) return;
+      this._log(`_applyNetworkStatus() - ${online ? "online" : "offline"}`);
+      if (!online) {
+        this._setState("CLOSED" /* Closed */);
+        this.abortController?.abort();
+        this.abortController = void 0;
+        return;
+      }
+      if (this.state === "CLOSED" /* Closed */) {
+        this.connect(true);
+      }
+    };
+    /**
+     * connect try to open a longpoll request
+     *
+     * @param reconnect - should be false for first call and true for subsequent calls to keep the connection alive and settle the connect promises
+     *
+     * @internal
+     */
+    this.connect = async (reconnect = false) => {
+      if (this.state === "CONNECTING" /* Connecting */) {
+        this._log("connect() - connecting already in progress", { reconnect }, "warn");
+        return;
+      }
+      if (this.state === "CONNECTED" /* Connected */) {
+        this._log("connect() - already connected and polling", { reconnect }, "warn");
+        return;
+      }
+      this._setState("CONNECTING" /* Connecting */);
+      this.client.connectionIdManager.arm();
+      try {
+        const { event } = await this._req(
+          // Authenticated by the request's `Authorization` header, so the message carries only a
+          // placeholder token.
+          { json: this.client._buildWSAuthPayload() },
+          { timeout: 8e3 },
+          // 8s
+          reconnect
+        );
+        this.client.connectionIdManager.resolveConnectionId(event.connection_id);
+        this._setState("CONNECTED" /* Connected */);
+        this.client.dispatchEvent(event);
+        this._poll();
+        if (reconnect) {
+          this.client._settleConnectPromises();
+        }
+        return event;
+      } catch (err) {
+        if (this.state !== "DISCONNECTED" /* Disconnected */)
+          this._setState("CLOSED" /* Closed */);
+        if (!import_axios4.default.isCancel(err)) this.client.connectionIdManager.rejectConnectionId(err);
+        throw err;
+      }
+    };
+    /**
+     * Stops polling and tells the server to close `connectionId`.
+     *
+     * @param timeout - The close request's timeout, in milliseconds.
+     * @param connectionId - The id to close. Passed in rather than read from
+     *   `client.connectionIdManager`, because `WSConnection.disconnect()` disconnects the old socket
+     *   first, and that drops the manager's id.
+     *
+     * @internal
+     */
+    this.disconnect = async (timeout = 2e3, connectionId) => {
+      this._setState("DISCONNECTED" /* Disconnected */);
+      this.abortController?.abort();
+      this.abortController = void 0;
+      try {
+        await this._req({ close: true, connection_id: connectionId }, { timeout }, false);
+        this._log(`disconnect() - Closed connectionID`);
+      } catch (err) {
+        this._log(`disconnect() - Failed`, { err }, "error");
+      }
+    };
+    this._req = async (params, config, retry) => {
+      if (!this.abortController && !params.close) {
+        this.abortController = new AbortController();
+      }
+      try {
+        const res = await this.client.longPoll(params, {
+          ...config,
+          signal: this.abortController?.signal
+        });
+        this.consecutiveFailures = 0;
+        return res;
+      } catch (error) {
+        this.consecutiveFailures += 1;
+        if (retry && isErrorRetryable(error)) {
+          this._log(`_req() - Retryable error, retrying request`);
+          await sleep(retryInterval(this.consecutiveFailures));
+          if (params.connection_id && params.connection_id !== this.client.connectionIdManager.connectionId) {
+            this._log(`_req() - Connection id changed, dropping the retry`);
+            throw new import_axios4.CanceledError(
+              "The connection id changed while the retry was waiting"
+            );
+          }
+          return this._req(params, config, retry);
+        }
+        throw error;
+      }
+    };
+    this._poll = async () => {
+      while (this.state === "CONNECTED" /* Connected */) {
+        try {
+          const data = await this._req(
+            { connection_id: this.client.connectionIdManager.connectionId },
+            { timeout: 3e4 },
+            // 30s => API responds in 20s if there is no event
+            true
+          );
+          if (data.events?.length) {
+            for (let i = 0; i < data.events.length; i++) {
+              this.client.dispatchEvent(data.events[i]);
+            }
+          }
+        } catch (error) {
+          if (import_axios4.default.isCancel(error)) {
+            this._log(`_poll() - axios canceled request`);
+            return;
+          }
+          if (isConnectionIDError(error)) {
+            this._log(`_poll() - ConnectionID error, connecting without ID...`);
+            this._setState("DISCONNECTED" /* Disconnected */);
+            this.connect(true);
+            return;
+          }
+          if (isAPIError(error) && !isErrorRetryable(error)) {
+            this._setState("CLOSED" /* Closed */);
+            this.client.connectionIdManager.rejectConnectionId(error);
+            return;
+          }
+          await sleep(retryInterval(this.consecutiveFailures));
+        }
+      }
+    };
+    this.client = client;
+    this.state = "INIT" /* Init */;
+    this.consecutiveFailures = 0;
+  }
+  /**
+   * Whether a connect request is in flight.
+   *
+   * @internal
+   */
+  get isConnecting() {
+    return this.state === "CONNECTING" /* Connecting */;
+  }
+  _log(msg, extra = {}, level = "info") {
+    const log = logger15.withExtraTags("connection_fallback");
+    log[level]("WSConnectionFallback:" + msg, extra);
+  }
+  _setState(state) {
+    this._log(`_setState() - ${state}`);
+    const previous = this.state;
+    this.state = state;
+    if (previous === "CONNECTING" /* Connecting */ && this.state === "CONNECTED" /* Connected */) {
+      this.client.wsConnection._setStatus({ isHealthy: true });
+    }
+    if (this.state === "CLOSED" /* Closed */ || this.state === "DISCONNECTED" /* Disconnected */) {
+      this.client.connectionIdManager.invalidate();
+      if (this.client.wsConnection._setStatus({ isHealthy: false })) {
+        this.client._markActiveChannelsWatchInterrupted();
+      }
+    }
+  }
+};
+
+// src/connection/wsConnection/WSConnection.ts
+var logger16 = chatLoggerSystem.getLogger("client");
 var WSConnection = class extends WithSubscriptions {
   constructor({ client }) {
     super();
@@ -21244,6 +21445,9 @@ var WSConnection = class extends WithSubscriptions {
      *
      * Read from the store rather than from an event, so there is one description of the device's
      * network rather than two that can disagree.
+     *
+     * After an `enableWSFallback` switch it routes to {@link fallback} instead, leaving the
+     * disconnected socket out of it.
      */
     this.registerSubscriptions = () => {
       if (!this.hasSubscriptions) {
@@ -21252,7 +21456,7 @@ var WSConnection = class extends WithSubscriptions {
             ({ isOnline }) => ({ isOnline }),
             ({ isOnline }) => {
               if (typeof isOnline !== "boolean") return;
-              this.connection?._applyNetworkStatus(isOnline);
+              (this.fallback ?? this.connection)?._applyNetworkStatus(isOnline);
             }
           )
         );
@@ -21305,7 +21509,7 @@ var WSConnection = class extends WithSubscriptions {
     for (const correction of corrections) {
       if (this.warnedClamps.get(correction.field) === correction.requested) continue;
       this.warnedClamps.set(correction.field, correction.requested);
-      logger15.withExtraTags("wsConnection").warn(
+      logger16.withExtraTags("wsConnection").warn(
         `The WebSocket setting '${correction.field}' is outside its supported range; using ${correction.used}ms instead of ${correction.requested}ms.`,
         { bounds: WS_CONNECTION_CONFIG_BOUNDS[correction.field] }
       );
@@ -21324,22 +21528,24 @@ var WSConnection = class extends WithSubscriptions {
     this.configController.initialize(config);
   }
   /**
-   * Is this WebSocket up. Read from {@link state} rather than from the current socket, so it
-   * survives the socket being replaced and answers `false` rather than throwing before the first
-   * connect.
+   * Is this WebSocket up — or, after an `enableWSFallback` switch, the long-poll. Read from
+   * {@link state} rather than from the current socket, so it survives the socket being replaced and
+   * answers `false` rather than throwing before the first connect.
    */
   get isHealthy() {
     return this.state.getLatestValue().isHealthy;
   }
-  /** Whether a connection attempt is in flight. */
+  /** Whether a connection attempt is in flight — the long-poll's after an `enableWSFallback` switch. */
   get isConnecting() {
-    return this.connection?.isConnecting ?? false;
+    return (this.fallback ?? this.connection)?.isConnecting ?? false;
   }
   /**
-   * Records this WebSocket's status. Returns whether it changed.
+   * Records this connection's status. Returns whether it changed.
    *
-   * {@link StableWSConnection} is the only caller, and it routes **every** status transition through
-   * here — including `disconnect()`, which `closeConnection()` uses, and the two error paths.
+   * {@link StableWSConnection} routes **every** status transition through here — including
+   * `disconnect()`, which `closeConnection()` uses, and the two error paths. The one other
+   * caller is {@link fallback}, which takes over once `enableWSFallback` has switched to
+   * long-polling.
    *
    * @internal
    */
@@ -21362,19 +21568,45 @@ var WSConnection = class extends WithSubscriptions {
    * Creation lives here rather than in the constructor because a client that never calls
    * `connectUser` should never build a socket, and here rather than in `client.connect()` because a
    * field belongs to the object that owns it.
+   *
+   * With `enableWSFallback`, a socket that fails with a network error is replaced by the long-poll
+   * ({@link fallback}), which every later call connects instead of building a socket.
    */
-  connect(timeout) {
+  async connect(timeout) {
+    if (this.fallback) {
+      return await this.fallback.connect();
+    }
     const next = this.buildConnection();
     const previous = this.connection;
     if (previous && previous !== next) {
       void Promise.resolve(previous.disconnect()).catch((error) => {
-        logger15.withExtraTags("wsConnection").debug("Closing the replaced WebSocket failed; discarding it anyway.", {
+        logger16.withExtraTags("wsConnection").debug("Closing the replaced WebSocket failed; discarding it anyway.", {
           error
         });
       });
     }
     this.connection = next;
-    return next.connect(timeout);
+    try {
+      return await next.connect(timeout);
+    } catch (error) {
+      const { networkConnection } = this.client;
+      const isDeviceOffline = networkConnection.isOnline === false && !networkConnection.usesDefaultWSConnectionNetworkStatusReporter;
+      if (this.config.enableWSFallback && isWSFailure(error) && !isDeviceOffline) {
+        logger16.withExtraTags("connect").info("WS failed, fallback to longpoll");
+        this.client.dispatchEvent({
+          type: "connection.fallback_activated",
+          mode: "longpoll"
+        });
+        next._destroyCurrentWSConnection();
+        void next.disconnect();
+        this.fallback = new WSConnectionFallback({ client: this.client });
+        return await this.fallback.connect();
+      }
+      if (!isWSFailure(error)) {
+        this.client.connectionIdManager.rejectConnectionId(error);
+      }
+      throw error;
+    }
   }
   /**
    * `config.connection` lets a caller supply a pre-built socket — used by unit tests, and the reason
@@ -21388,8 +21620,17 @@ var WSConnection = class extends WithSubscriptions {
     }
     return new StableWSConnection({ wsConnection: this });
   }
-  disconnect(timeout) {
-    return this.connection?.disconnect(timeout);
+  /**
+   * Closes the socket and, after an `enableWSFallback` switch, the long-poll too, telling the
+   * server to close its connection id. The long-poll's close request uses `timeout` as its timeout
+   * (2s when omitted).
+   */
+  async disconnect(timeout) {
+    const connectionId = this.client.connectionIdManager.connectionId;
+    await Promise.all([
+      this.connection?.disconnect(timeout),
+      this.fallback?.disconnect(timeout, connectionId)
+    ]);
   }
   /**
    * @deprecated Report network status through `client.networkConnection.setStatus(isOnline)` instead,
@@ -21891,7 +22132,7 @@ var CONSTRUCTION_ONLY_CONFIG_PATHS = {
 };
 
 // src/configuration/InstanceConfigurationRegistry.ts
-var logger16 = chatLoggerSystem.getLogger("instance-configuration");
+var logger17 = chatLoggerSystem.getLogger("instance-configuration");
 var InstanceConfigurationRegistry = class {
   constructor() {
     /**
@@ -22089,7 +22330,7 @@ var InstanceConfigurationRegistry = class {
       try {
         instance.reinitializeConfig?.();
       } catch (error) {
-        logger16.error("reinitializeConfig threw during reset", error);
+        logger17.error("reinitializeConfig threw during reset", error);
       }
     }
   }
@@ -22147,7 +22388,7 @@ var InstanceConfigurationRegistry = class {
   warnIfKeyLooksUnknown(key) {
     if (INSTANCE_CONFIG_TREE_KEYS.includes(key)) return;
     if (this.hasLiveInstances(key)) return;
-    logger16.withExtraTags(key).warn(
+    logger17.withExtraTags(key).warn(
       "Configuration registered for a key this package does not define, with nothing subscribed to it. Check the spelling; a key declared by a downstream SDK is expected here only if its owner subscribes later."
     );
   }
@@ -22174,7 +22415,7 @@ var InstanceConfigurationRegistry = class {
       return !isEqual(getPath(registered, path), getPath(config, path));
     });
     if (late.length === 0) return;
-    logger16.withExtraTags(key).warn(
+    logger17.withExtraTags(key).warn(
       `These paths are read once during construction, so they will not affect the ${key} instance(s) that already exist: ${late.join(", ")}. Register configuration before the instances are created \u2014 typically alongside StreamChat.getInstance().`
     );
   }
@@ -23525,6 +23766,7 @@ var ChatApi = class {
   }
   async longPoll(request, requestOptions) {
     const queryParams = {
+      close: request?.close,
       connection_id: request?.connection_id,
       json: request?.json
     };
@@ -24137,7 +24379,7 @@ var ChatApi = class {
 function isString(value) {
   return typeof value === "string" || value instanceof String;
 }
-var logger17 = chatLoggerSystem.getLogger("client");
+var logger18 = chatLoggerSystem.getLogger("client");
 var offlineDbLogger2 = chatLoggerSystem.getLogger("offline-db");
 var markThreadChannelWatched = ({ channel }) => {
   channel.watchStatus = ChannelWatchStatus.Watching;
@@ -24196,7 +24438,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         throw new Error('The "id" field on the user is missing');
       }
       if (this.userId === user.id && this.setUserPromise) {
-        logger17.withExtraTags("connectUser").warn(
+        logger18.withExtraTags("connectUser").warn(
           "Detected consecutive calls to connectUser. Ideally, this function should only be called once."
         );
         return this.setUserPromise;
@@ -24207,7 +24449,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         );
       }
       if (this.node && !this.options.allowServerSideConnect) {
-        logger17.withExtraTags("connectUser").warn(
+        logger18.withExtraTags("connectUser").warn(
           'Do not use connectUser server-side. connectUser impacts MAU and concurrent connection usage, and therefore your bill. If you have a valid use case, set "allowServerSideConnect: true" in the client options to disable this warning.'
         );
       }
@@ -24253,8 +24495,12 @@ var StreamChat = class _StreamChat extends ChatApi {
      * So when your app goes to background, you can call `client.closeConnection`.
      * And when app comes back to foreground, call `client.openConnection`.
      *
+     * After an `enableWSFallback` switch it closes the long-poll as well, telling the server to
+     * close its connection id.
+     *
      * @param timeout - Max number of milliseconds to wait for the WebSocket close event before forcefully assuming
      *   successful disconnection. See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent (optional).
+     *   The long-poll's close request uses it as its timeout (2s when omitted).
      */
     this.closeConnection = async (timeout) => {
       this._resetAIStateOnActiveChannels();
@@ -24278,7 +24524,8 @@ var StreamChat = class _StreamChat extends ChatApi {
       return Promise.resolve();
     };
     /**
-     * Creates a new WebSocket connection with the current user.
+     * Creates a new WebSocket connection with the current user. After an `enableWSFallback` switch it
+     * reconnects the long-poll instead: the client never goes back to the WebSocket.
      *
      * @returns The WebSocket connect promise, or an empty resolved promise if a connection is already active.
      */
@@ -24289,11 +24536,11 @@ var StreamChat = class _StreamChat extends ChatApi {
         );
       }
       if (this.wsConnection?.isConnecting && this.wsPromise) {
-        logger17.withExtraTags("openConnection").debug("A connection attempt is already in progress.");
+        logger18.withExtraTags("openConnection").debug("A connection attempt is already in progress.");
         return this.wsPromise;
       }
       if (this.wsConnection?.isHealthy && this.connectionIdManager.connectionId) {
-        logger17.withExtraTags("openConnection").debug("openConnection was called twice; a healthy connection already exists.");
+        logger18.withExtraTags("openConnection").debug("openConnection was called twice; a healthy connection already exists.");
         return;
       }
       this.clientId = `${this.userId}--${randomId()}`;
@@ -24350,7 +24597,7 @@ var StreamChat = class _StreamChat extends ChatApi {
      * @returns The close-connection promise.
      */
     this.disconnectUser = (timeout) => {
-      logger17.withExtraTags("disconnectUser").info("Disconnecting the client.");
+      logger18.withExtraTags("disconnectUser").info("Disconnecting the client.");
       delete this.user;
       delete this._user;
       const teardownReason = new Error(
@@ -24358,8 +24605,8 @@ var StreamChat = class _StreamChat extends ChatApi {
       );
       this._rejectPendingWsPromise(teardownReason);
       this.wsPromise = null;
-      this.connectionIdManager.rejectConnectionId(teardownReason);
       const closePromise = this.closeConnection(timeout);
+      this.connectionIdManager.rejectConnectionId(teardownReason);
       for (const channel of Object.values(this.activeChannels)) {
         channel._disconnect();
       }
@@ -24373,9 +24620,9 @@ var StreamChat = class _StreamChat extends ChatApi {
       this.unsubscribeClientConfiguration?.();
       this.unsubscribeClientConfiguration = void 0;
       closePromise.finally(() => {
-        this.tokenManager.reset();
+        if (!this.userId) this.tokenManager.reset();
       }).catch(
-        (err) => logger17.withExtraTags("disconnectUser").error("The close promise rejected during disconnect.", { error: err })
+        (err) => logger18.withExtraTags("disconnectUser").error("The close promise rejected during disconnect.", { error: err })
       );
       return closePromise;
     };
@@ -24393,7 +24640,7 @@ var StreamChat = class _StreamChat extends ChatApi {
      */
     this.connectAnonymousUser = () => {
       if (this.node && !this.options.allowServerSideConnect) {
-        logger17.withExtraTags("connectAnonymousUser").warn(
+        logger18.withExtraTags("connectAnonymousUser").warn(
           'Do not use connectUser server-side. connectUser impacts MAU and concurrent connection usage, and therefore your bill. If you have a valid use case, set "allowServerSideConnect: true" in the client options to disable this warning.'
         );
       }
@@ -24546,7 +24793,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         ...this.listeners.get(event.type) ?? []
       ];
       for (const listener of listeners) {
-        invokeEventListener(listener, event, logger17);
+        invokeEventListener(listener, event, logger18);
       }
     };
     /**
@@ -24557,15 +24804,16 @@ var StreamChat = class _StreamChat extends ChatApi {
      * Requests no longer settle against these: waiting for a connection id is the
      * {@link ConnectionIdManager}'s job, applied centrally in `ApiClient`.
      *
-     * Called by `StableWSConnection._reconnect()`. Recovery itself is owned by
-     * {@link ConnectionRecoveryManager}, which subscribes to the connection lifecycle and so covers
-     * every reconnect path — including `closeConnection()` → `openConnection()` (mobile backgrounding),
-     * which never reaches `_reconnect()` at all.
+     * Called by `StableWSConnection._reconnect()`, and by `WSConnectionFallback.connect(true)`
+     * for the long-poll's own reconnects. Recovery itself is owned by
+     * {@link ConnectionRecoveryManager}, which subscribes to the connection lifecycle and so
+     * covers every reconnect path — including `closeConnection()` → `openConnection()` (mobile
+     * backgrounding), which reaches neither.
      *
      * @internal
      */
     this._settleConnectPromises = () => {
-      logger17.withExtraTags("_settleConnectPromises").info(
+      logger18.withExtraTags("_settleConnectPromises").info(
         `Connection re-established with connection ID ${this.connectionIdManager.connectionId}.`
       );
       if (this._wsPromiseSettled) {
@@ -24655,7 +24903,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.16";
+        const version = "10.0.0-rc.17";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -24685,11 +24933,21 @@ var StreamChat = class _StreamChat extends ChatApi {
      *
      * @returns The JSON-encoded auth message.
      */
-    this._buildWSAuthMessage = () => JSON.stringify({
-      // The server requires a non-empty token even for anonymous connections, but
-      // skips JWT parsing for any string that is not shaped like one. Anonymous users
-      // have no token, so send a placeholder the server accepts and ignores.
-      token: this.tokenManager.getToken() || "anonymous",
+    this._buildWSAuthMessage = () => JSON.stringify(this._buildWSAuthPayload(this.tokenManager.getToken()));
+    /**
+     * The auth message itself — what {@link _buildWSAuthMessage} encodes for the WebSocket, and what
+     * the long-poll fallback sends as `longPoll()`'s `json` query param.
+     *
+     * @private
+     *
+     * @param token - The token the message carries. The long-poll passes none: it authenticates
+     *   through the request's `Authorization` header instead.
+     */
+    this._buildWSAuthPayload = (token) => ({
+      // The server requires a non-empty token, but skips JWT parsing for any string that is not
+      // shaped like one. Anonymous users have no token, and the long-poll does not send one, so both
+      // send a placeholder the server accepts and ignores.
+      token: token || "anonymous",
       // `connect()` rejects before reaching this when `_user` is unset.
       user_details: this._user,
       products: ["chat"]
@@ -24712,7 +24970,7 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.browser = options.browser ?? typeof window !== "undefined";
     this.node = !this.browser;
     this.options = { ...options };
-    this.axiosInstance = import_axios4.default.create({
+    this.axiosInstance = import_axios5.default.create({
       timeout: 3e3,
       withCredentials: false,
       ...this.options.axiosRequestConfig,
@@ -24969,14 +25227,14 @@ var StreamChat = class _StreamChat extends ChatApi {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
     const set = this.listeners.get(key) ?? /* @__PURE__ */ new Set();
-    logger17.withExtraTags("on").debug(`Attaching a listener for the "${key}" event.`);
+    logger18.withExtraTags("on").debug(`Attaching a listener for the "${key}" event.`);
     set.add(callback);
     if (!this.listeners.has(key)) {
       this.listeners.set(key, set);
     }
     return {
       unsubscribe: () => {
-        logger17.withExtraTags("on").debug(`Removing the listener for the "${key}" event.`);
+        logger18.withExtraTags("on").debug(`Removing the listener for the "${key}" event.`);
         set.delete(callback);
         if (!set.size) {
           this.listeners.delete(key);
@@ -24987,7 +25245,7 @@ var StreamChat = class _StreamChat extends ChatApi {
   off(callbackOrString, callbackOrNothing) {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
-    logger17.withExtraTags("off").debug(`Removing the listener for the "${key}" event.`);
+    logger18.withExtraTags("off").debug(`Removing the listener for the "${key}" event.`);
     const set = this.listeners.get(key);
     set?.delete(callback);
     if (!set?.size) {
@@ -24997,7 +25255,7 @@ var StreamChat = class _StreamChat extends ChatApi {
   _handleClientEvent(event) {
     const client = this;
     const postListenerCallbacks = [];
-    logger17.withExtraTags("_handleClientEvent").debug(`Received an event of type "${event.type}".`, { event });
+    logger18.withExtraTags("_handleClientEvent").debug(`Received an event of type "${event.type}".`, { event });
     if (event.type === "user.presence.changed" || event.type === "user.updated" || event.type === "user.deleted") {
       this._handleUserEvent(event);
     }
@@ -25074,10 +25332,13 @@ var StreamChat = class _StreamChat extends ChatApi {
    * Only `Watching` is demoted: a channel the consumer stopped on purpose, or one that was torn
    * down, stays `NotWatching` and must not be resurrected by a reconnect.
    *
-   * Invoked from two places, because neither covers the other: `StableWSConnection._setHealth(false)`
-   * for an abnormal close/error, and `closeConnection()` for a deliberate shutdown (e.g. mobile
-   * backgrounding), whose `disconnect()` writes the status through `_applyHealth` and so never
-   * reaches `_setHealth`.
+   * Invoked from two places on the WebSocket, because neither covers the other:
+   * `StableWSConnection._setHealth(false)` for an abnormal close/error, and
+   * `closeConnection()` for a deliberate shutdown (e.g. mobile backgrounding), whose
+   * `disconnect()` writes the status through `_applyHealth` and so never reaches
+   * `_setHealth`. After an `enableWSFallback` switch the long-poll calls it too, from
+   * `WSConnectionFallback._setState()` whenever going closed or disconnected takes the
+   * status offline.
    */
   _markActiveChannelsWatchInterrupted() {
     for (const cid in this.activeChannels) {
@@ -25126,14 +25387,7 @@ var StreamChat = class _StreamChat extends ChatApi {
     if (!this.clientId) {
       throw Error("Property clientId is not set");
     }
-    try {
-      return await this.wsConnection.connect();
-    } catch (error) {
-      if (!isWSFailure(error)) {
-        this.connectionIdManager.rejectConnectionId(error);
-      }
-      throw error;
-    }
+    return await this.wsConnection.connect();
   }
   /**
    * Queries users and watches user presence.
@@ -25150,6 +25404,31 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.state.updateUsers(data.users);
     return data;
   }
+  /**
+   * Stops watching a channel on this client's connection.
+   *
+   * It carries no `watch` flag, so the request layer does not hold it, but it is connection-scoped
+   * by definition: it tells the server which connection should stop watching. So it waits for this
+   * client's connection id exactly as a watching request does — through a handshake or a reconnect,
+   * until the caller's abort signal fires — and throws when there is no connection and none is being
+   * established.
+   *
+   * @param ...args - `[request, requestOptions]`. `request.connection_id` is replaced by this
+   *   client's connection id.
+   * @returns The server response.
+   */
+  async stopWatchingChannel(...args) {
+    const [request, requestOptions] = args;
+    const signal = requestOptions?.signal;
+    const connectionId = await this.connectionIdManager.getConnectionId(
+      // Check if signal is still usable - if it is read from offline DB, it has lost `addEventListener`.
+      typeof signal?.addEventListener === "function" ? signal : void 0
+    );
+    return super.stopWatchingChannel(
+      { ...request, connection_id: connectionId },
+      requestOptions
+    );
+  }
   /**
    * Queries channels and returns the full API response including top-level metadata such as
    * `predefined_filter`.
@@ -26077,6 +26356,11 @@ var WS_CONNECTION_FIELDS = {
     kind: "value",
     type: "number"
   },
+  enableWSFallback: {
+    description: "Falls back to HTTP long-polling (`/api/v2/longpoll`) when the WebSocket cannot connect, for networks that block WebSockets. The WebSocket connects within `connectTimeoutMs`, as without the flag; lower it to switch sooner. Dispatches `connection.fallback_activated` when it switches, and stays on long-poll from then on. Defaults to `false`. Was `StreamChatOptions.enableWSFallback`.",
+    kind: "value",
+    type: "boolean"
+  },
   offlineNotificationDisplayDelayMs: {
     description: "How long a drop must last before a UI reports it. Most drops resolve in under a second, so a banner showing all of them makes a working application look broken. Nothing in this package waits on it: it is here so the UI SDKs share one value. Zero holds nothing back, landing on the next task.",
     kind: "value",
@@ -26135,7 +26419,7 @@ var CLIENT_FIELDS = {
     kind: "group"
   },
   wsConnection: {
-    description: "This client's WebSocket: how long to wait for it, how often to ping it, how long it may go quiet before being declared dead, and how long a drop must last before a UI reports it.",
+    description: "This client's WebSocket: how long to wait for it, how often to ping it, how long it may go quiet before being declared dead, how long a drop must last before a UI reports it, and whether to fall back to long-polling when it cannot connect.",
     fields: WS_CONNECTION_FIELDS,
     kind: "group"
   }
@@ -26359,8 +26643,8 @@ var OfflineError = class extends Error {
 };
 
 // src/offline-support/offline_sync_manager.ts
-var import_axios5 = require("axios");
-var logger18 = chatLoggerSystem.getLogger("offline-db");
+var import_axios6 = require("axios");
+var logger19 = chatLoggerSystem.getLogger("offline-db");
 var OfflineDBSyncManager = class {
   constructor({
     client,
@@ -26404,7 +26688,7 @@ var OfflineDBSyncManager = class {
           }
         );
       } catch (error) {
-        logger18.withExtraTags("init").error("Failed to initialize the offline DB sync manager.", { error });
+        logger19.withExtraTags("init").error("Failed to initialize the offline DB sync manager.", { error });
       }
     };
     /**
@@ -26494,7 +26778,7 @@ var OfflineDBSyncManager = class {
             const { syncMaxEventCount } = this;
             const exceedsLimit = typeof syncMaxEventCount === "number" && syncMaxEventCount > 0 && result.events.length > syncMaxEventCount;
             if (exceedsLimit) {
-              logger18.withExtraTags("sync").warn(
+              logger19.withExtraTags("sync").warn(
                 `Skipping sync event replay: received ${result.events.length} events, which exceeds the configured limit of ${syncMaxEventCount}. Visible channels are refreshed on reconnect instead.`
               );
             } else {
@@ -26514,8 +26798,8 @@ var OfflineDBSyncManager = class {
           lastSyncedAt: (/* @__PURE__ */ new Date()).toString()
         });
       } catch (e) {
-        logger18.withExtraTags("syncAndExecutePendingTasks").error("An error occurred while syncing the database.", { error: e });
-        if ((0, import_axios5.isAxiosError)(e) && e.code === "ECONNABORTED") {
+        logger19.withExtraTags("syncAndExecutePendingTasks").error("An error occurred while syncing the database.", { error: e });
+        if ((0, import_axios6.isAxiosError)(e) && e.code === "ECONNABORTED") {
           return;
         }
         const error = e;
@@ -26555,7 +26839,7 @@ var OfflineDBSyncManager = class {
 
 // src/offline-support/offline_support_api.ts
 var import_state_store30 = require("@stream-io/state-store");
-var logger19 = chatLoggerSystem.getLogger("offline-db");
+var logger20 = chatLoggerSystem.getLogger("offline-db");
 var AbstractOfflineDB = class {
   constructor({
     client,
@@ -26580,7 +26864,7 @@ var AbstractOfflineDB = class {
         }
       } catch (error) {
         this.state.partialNext({ initialized: false, userId: void 0 });
-        logger19.withExtraTags("init").error("Failed to initialize the offline database.", { error });
+        logger20.withExtraTags("init").error("Failed to initialize the offline database.", { error });
       }
     };
     /**
@@ -26672,7 +26956,7 @@ var AbstractOfflineDB = class {
         }
       }
       if (!channelData) {
-        logger19.withExtraTags("queriesWithChannelGuard").warn(
+        logger20.withExtraTags("queriesWithChannelGuard").warn(
           `Received a "${type}" event for a non-initialized channel that is not in the database. Skipping the event.`,
           { event }
         );
@@ -26683,7 +26967,7 @@ var AbstractOfflineDB = class {
         execute: false
       });
       if (!channelQuery) {
-        logger19.withExtraTags("queriesWithChannelGuard").warn(
+        logger20.withExtraTags("queriesWithChannelGuard").warn(
           `Could not create channel queries on a "${type}" event for an initialized channel that is not in the database. Skipping the event.`,
           { event }
         );
@@ -26878,7 +27162,7 @@ var AbstractOfflineDB = class {
     }) => {
       const channel = this.client.activeChannels[cid];
       if (!channel?.initialized || channel.pendingDisposal) {
-        logger19.withExtraTags("upsertMessageWithChannelGuard", cid).warn("Skipping message persistence: the channel is not in the database.");
+        logger20.withExtraTags("upsertMessageWithChannelGuard", cid).warn("Skipping message persistence: the channel is not in the database.");
         return [];
       }
       const queries = [