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

package/dist/cjs/index.browser.js

@@ -71,6 +71,8 @@ __export(src_exports, {
   DEFAULT_STOP_REFRESH_BOUNDARY_MS: () => DEFAULT_STOP_REFRESH_BOUNDARY_MS,
   DEFAULT_TEXT_COMPOSER_CONFIG: () => DEFAULT_TEXT_COMPOSER_CONFIG,
   DEFAULT_THREAD_MANAGER_CONFIG: () => DEFAULT_THREAD_MANAGER_CONFIG,
+  DEFAULT_THREAD_PAGE_SIZE: () => DEFAULT_THREAD_PAGE_SIZE,
+  DEFAULT_THREAD_QUERY: () => DEFAULT_THREAD_QUERY,
   DEFAULT_WS_CONNECTION_CONFIG: () => DEFAULT_WS_CONNECTION_CONFIG,
   EntityStore: () => EntityStore,
   EventHandlerPipeline: () => EventHandlerPipeline,
@@ -125,6 +127,7 @@ __export(src_exports, {
   TextComposerMiddlewareExecutor: () => TextComposerMiddlewareExecutor,
   Thread: () => Thread,
   ThreadManager: () => ThreadManager,
+  ThreadPaginator: () => ThreadPaginator,
   TokenManager: () => TokenManager,
   UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT: () => UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT,
   UploadManager: () => UploadManager,
@@ -263,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 = {
@@ -1446,6 +1449,14 @@ var EntityStore = class {
   has(id) {
     return this.byId.has(id);
   }
+  /** Whether `subscriber` is one of the holders of `id`. */
+  isHeldBy(id, subscriber) {
+    return this.subscribers.get(id)?.has(subscriber) ?? false;
+  }
+  /** Every entity currently in the store. */
+  values() {
+    return Array.from(this.byId.values());
+  }
   // ---- writes ----
   /**
    * Replaces the canonical copy of `entity` and notifies every subscriber watching its id —
@@ -2613,6 +2624,16 @@ var BasePaginator = class {
    * {@link setIntervals}), which bypasses the per-interval {@link commitInterval}/{@link dropInterval}
    * publishing. No-ops when the views are already empty so a reset does not emit needlessly.
    */
+  /**
+   * Drops every loaded interval and item without publishing anything, so the next ingest starts from
+   * empty storage while `state.items` keeps showing the previous window until the caller publishes.
+   */
+  clearItemStorage() {
+    this.setIntervals([]);
+    this.setActiveInterval(void 0);
+    this._itemIndex.clear();
+    this.clearIntervalViews();
+  }
   clearIntervalViews() {
     this._pendingViewChangedIds.clear();
     const { logicalHead, logicalTail, anchoredHead } = this.intervalViews.getLatestValue();
@@ -4080,10 +4101,7 @@ var BasePaginator = class {
     if (!this.canExecuteQuery({ direction, reset })) return;
     const isForcedReset = reset === "yes" && !keepPreviousItems;
     if (isForcedReset) {
-      this.setIntervals([]);
-      this.setActiveInterval(void 0);
-      this._itemIndex.clear();
-      this.clearIntervalViews();
+      this.clearItemStorage();
       this.state.next(this.getStateBeforeFirstQuery());
     } else if (reset === "yes" && !forcedQueryShape) {
       this.state.partialNext({
@@ -4091,7 +4109,9 @@ var BasePaginator = class {
         offset: this.config.initialOffset ?? 0
       });
     }
-    const queryShape = forcedQueryShape ?? this.getNextQueryShape({ direction });
+    const isRefresh = reset === "yes" && keepPreviousItems && !forcedQueryShape;
+    const pageSize = isRefresh ? Math.max(this.pageSize, this.items?.length ?? 0) : this.pageSize;
+    const queryShape = forcedQueryShape ?? this.getNextQueryShape({ direction, pageSize });
     const isFirstPage = this.isFirstPageQuery({ queryShape, reset });
     if (isFirstPage && !keepPreviousItems) {
       const state = this.getStateBeforeFirstQuery();
@@ -4155,6 +4175,7 @@ var BasePaginator = class {
     const filteredItems = this.filterQueryResults(items);
     stateUpdate.items = filteredItems;
     const isJumpQuery = !!queryShape && this.isJumpQueryShape(queryShape);
+    const keptItemIds = isFirstPage && keepPreviousItems && !this.isCursorPagination && this.items?.length ? new Set(this.items.map((item) => this.getItemId(item))) : void 0;
     const interval = this.ingestPage({
       page: stateUpdate.items,
       policy: isJumpQuery ? "strict-overlap-only" : "auto",
@@ -4196,7 +4217,15 @@ var BasePaginator = class {
     } else {
       const startOffset = this.offset ?? 0;
       stateUpdate.offset = startOffset + items.length;
-      stateUpdate.hasMoreTail = items.length === this.pageSize;
+      const lastPageItem = items[items.length - 1];
+      if (interval && keptItemIds && lastPageItem && keptItemIds.has(this.getItemId(lastPageItem))) {
+        stateUpdate.offset = Math.max(
+          stateUpdate.offset,
+          startOffset + this.intervalToItems(interval).length
+        );
+      }
+      stateUpdate.hasMoreTail = items.length >= this.pageSize;
+      if (isFirstPage) stateUpdate.hasMoreHead = (this.config.initialOffset ?? 0) > 0;
     }
     if (interval) {
       const current = this.state.getLatestValue();
@@ -4224,7 +4253,7 @@ var BasePaginator = class {
     }
     const state = this.getStateAfterQuery(stateUpdate, isFirstPage);
     if (updateState) this.state.next(state);
-    this.populateOfflineDbAfterQuery({ items: state.items, queryShape });
+    if (isFirstPage) this.populateOfflineDbAfterQuery({ items: state.items, queryShape });
     return {
       stateCandidate: state,
       targetInterval: interval
@@ -5854,7 +5883,7 @@ var QUEUEABLE_OPERATIONS = {
       const message = result?.message;
       if (!message) return;
       if (message.parent_id) {
-        client.threads.threadsById[message.parent_id]?.upsertReplyLocally({
+        client.threads.get(message.parent_id)?.upsertReplyLocally({
           message,
           timestampChanged: true
         });
@@ -7715,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;
@@ -8153,6 +8185,8 @@ var ChannelPaginator = class extends BasePaginator {
      * continuation rather than a first page. See `executeQuery`.
      */
     this._itemsLoadedFromOfflineDB = false;
+    /** The query in flight refreshes a cache-only window, so its response replaces the window. */
+    this._replaceOfflineSeedOnResponse = false;
     /**
      * Filters sent to the server with the next query (and used as the offline-db query key). Deliberately
      * built from the locally configured filters only — feeding the backend-resolved filter back in would
@@ -8209,6 +8243,7 @@ var ChannelPaginator = class extends BasePaginator {
       });
     };
     this.query = async () => {
+      if (this._itemsLoadedFromOfflineDB) this._replaceOfflineSeedOnResponse = true;
       this._itemsLoadedFromOfflineDB = false;
       if (!this._nextQueryShape) {
         this._nextQueryShape = this.getNextQueryShape();
@@ -8376,14 +8411,22 @@ var ChannelPaginator = class extends BasePaginator {
     if (params.isFirstPage && params.results) {
       this.applyPredefinedFilterResponse(pendingPredefinedFilter);
     }
+    const replaceOfflineSeed = this._replaceOfflineSeedOnResponse;
+    this._replaceOfflineSeedOnResponse = false;
+    if (replaceOfflineSeed && params.results) {
+      this.clearItemStorage();
+      return super.postQueryReconcile({ ...params, keepPreviousItems: false });
+    }
     return super.postQueryReconcile(params);
   }
   // invoked inside BasePaginator.executeQuery() to keep it as a query descriptor;
-  getNextQueryShape() {
+  getNextQueryShape({
+    pageSize
+  } = {}) {
     const shape = {
       filter_conditions: this.buildQueryFilters(),
       ...this.options,
-      limit: this.pageSize,
+      limit: pageSize ?? this.pageSize,
       offset: this.offset
     };
     if (this.sort) {
@@ -8420,7 +8463,7 @@ var ChannelPaginator = class extends BasePaginator {
   }) {
     this.client.offlineDb?.executeQuerySafely(
       (db) => db.upsertCidsForQuery({
-        cids,
+        cids: cids.slice(0, this.pageSize),
         filters: request.filter_conditions,
         options: request,
         predefinedFilter: this._predefinedFilter,
@@ -9022,6 +9065,130 @@ var UserGroupPaginator = class extends BasePaginator {
   }
 };
 
+// src/pagination/paginators/ThreadPaginator.ts
+var DEFAULT_THREAD_PAGE_SIZE = 25;
+var DEFAULT_THREAD_QUERY = {
+  participant_limit: 10,
+  reply_limit: 10,
+  watch: true
+};
+var getQueryIdentity2 = (queryShape) => {
+  if (!queryShape) return queryShape;
+  const { limit: _, next: __, prev: ___, ...identity } = queryShape;
+  return identity;
+};
+var hasPaginationQueryShapeChanged3 = (prevQueryShape, nextQueryShape) => !isEqual(getQueryIdentity2(prevQueryShape), getQueryIdentity2(nextQueryShape));
+var ThreadPaginator = class extends BasePaginator {
+  constructor({
+    client,
+    store = new EntityStore({ getEntityId: (thread) => thread.id }),
+    paginatorOptions
+  }) {
+    super({
+      hasPaginationQueryShapeChanged: hasPaginationQueryShapeChanged3,
+      initialCursor: ZERO_PAGE_CURSOR,
+      itemIndex: new StoreBackedItemIndex({
+        getEntityId: (thread) => thread.id,
+        store
+      }),
+      pageSize: DEFAULT_THREAD_PAGE_SIZE,
+      ...paginatorOptions
+    });
+    this.query = async ({
+      queryShape
+    }) => {
+      const { threads, next } = await this.client.queryThreadsAndHydrate(queryShape);
+      return { items: threads.map(this.toStoredInstance), tailward: next };
+    };
+    /**
+     * The stored instance for a queried thread, so there's one per id. The index upserts, so a second
+     * instance would replace the stored one. A stale stored thread is refreshed from the query, unless
+     * it's open (active) at which point it reloads itself and this would replace the replies on screen.
+     */
+    this.toStoredInstance = (incoming) => {
+      const stored = this.store.get(incoming.id);
+      if (!stored) return incoming;
+      if (stored.hasStaleState && !stored.state.getLatestValue().active) {
+        stored.hydrateState(incoming);
+      }
+      return stored;
+    };
+    this.filterQueryResults = (threads) => threads;
+    /**
+     * Re-queries the first page and swaps the list in place, in server order; also the first load. The
+     * current threads stay until the response lands, and a failed query leaves them untouched and
+     * records `lastQueryError`; a successful one clears it. Like any paginator, the first load publishes
+     * `isLoading`; a reload of a loaded list does not, since `isLoading` with items means the next page.
+     */
+    this.reload = async ({ limit = this.pageSize } = {}) => {
+      const isFirstLoad = !this.hasResults;
+      if (isFirstLoad) this.state.partialNext({ isLoading: true });
+      let replaced = false;
+      try {
+        const results = await this.runQueryRetryable({
+          queryShape: { ...DEFAULT_THREAD_QUERY, limit },
+          retryCount: this.config.retryCount
+        });
+        if (!results) return;
+        const nextIds = new Set(results.items.map((thread) => thread.id));
+        this.setIntervals([]);
+        this.setActiveInterval(void 0);
+        for (const [id] of this._itemIndex.entries()) {
+          if (!nextIds.has(id)) this._itemIndex.remove(id);
+        }
+        this.setItems({
+          cursor: { headward: void 0, tailward: results.tailward },
+          isFirstPage: true,
+          isLastPage: !results.tailward,
+          valueOrFactory: results.items
+        });
+        replaced = true;
+      } finally {
+        const clearError = replaced && this.lastQueryError;
+        if (isFirstLoad || clearError) {
+          this.state.partialNext({
+            ...isFirstLoad ? { isLoading: false } : {},
+            ...clearError ? { lastQueryError: void 0 } : {}
+          });
+        }
+      }
+    };
+    this.client = client;
+    this.store = store;
+  }
+  /**
+   * No next page until a load has landed (`master`'s `nextCursor: null`), so `toTail()` is a no-op
+   * before the first successful reload, e.g. when an empty list fires `onEndReached` on mount.
+   */
+  get initialState() {
+    return {
+      ...super.initialState,
+      hasMoreTail: false
+    };
+  }
+  getItemId(thread) {
+    return thread.id;
+  }
+  getNextQueryShape({
+    direction
+  }) {
+    const cursor = this.cursor?.[direction] ?? void 0;
+    return {
+      ...DEFAULT_THREAD_QUERY,
+      limit: this.pageSize,
+      ...cursor ? { [direction === "tailward" ? "next" : "prev"]: cursor } : {}
+    };
+  }
+  /**
+   * Also releases the list's hold on its threads, which the base reset leaves in the index. Released
+   * before the base publishes, so a subscriber sees the threads already gone from the registry.
+   */
+  resetState() {
+    this._itemIndex.clear();
+    super.resetState();
+  }
+};
+
 // src/search/ChannelMemberSearchSource.ts
 var ChannelMemberSearchSource = class extends BaseSearchSource {
   constructor(channel, options, filterBuilderOptions = {}) {
@@ -12621,7 +12788,7 @@ var createMessageOperations = (collection) => {
       channel.messagePaginator.removeItem({ id });
       channel.pinnedMessagesPaginator.removeItem({ id });
       if (parentId) {
-        client.threads.threadsById[parentId]?.messagePaginator.removeItem({ id });
+        client.threads.get(parentId)?.messagePaginator.removeItem({ id });
       }
     },
     ...parentMessageId ? {
@@ -12666,7 +12833,7 @@ var createMessageOperations = (collection) => {
       update: async (m, o) => {
         const result = await channel.getClient().updateMessage({
           id: m.id,
-          message: localMessageToNewMessagePayload(m),
+          message: toUpdatedMessagePayload(m),
           ...o
         });
         return { message: result.message };
@@ -12777,10 +12944,15 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
      * reload on reconnect, so an unbalanced `deactivate()` now costs more than a missed auto-read —
      * hence the refcount, matching `channel.activate()`. A thread held by more than one mount stays
      * active until the last holder releases it.
+     *
+     * The first activation also keeps the thread in `client.threads` for the rest of the session:
+     * it stays subscribed and resolvable through `client.threads.get(id)` after it is deactivated,
+     * whether or not the thread list holds it. Reopening it therefore needs no fetch unless it went stale.
      */
     this.activate = () => {
       this._activeRefCount += 1;
       if (this._activeRefCount === 1) {
+        this.client.threads.register(this);
         this.state.partialNext({ active: true });
       }
     };
@@ -12802,10 +12974,9 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
      *
      * Preserves failed (unsent) replies. They are read out of the reply paginator rather than out of
      * `failedRepliesMap`, because that map is only written by `upsertReplyLocally`, whose callers are
-     * this thread's own subscriptions and the offline-DB path keyed on `ThreadManager.threadsById` —
-     * neither of which covers a thread constructed directly and never registered (the common path in
-     * the React Native SDK, which resolves `threadsById[id] ?? new Thread(...)`). Reading the paginator
-     * is true for managed and unmanaged threads alike. An overlap merge keeps them anyway (the
+     * this thread's own subscriptions and the offline-DB path resolved through `client.threads.get` —
+     * neither of which covers a thread that was never activated or listed. Reading the paginator
+     * is true for registered and unregistered threads alike. An overlap merge keeps them anyway (the
      * reconcile's provenance guard never prunes a non-server message); only a disjoint rebuild can drop
      * them, so any that actually fell out are re-ingested below.
      *
@@ -12889,6 +13060,7 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
         this.client.messageStore.upsert(parentMessage);
       }
       const incomingReplies = thread.messagePaginator.state.getLatestValue().items ?? [];
+      if (!options?.reconcile) this.messagePaginator.clearStateAndCache();
       if (typeof this.messagePaginator.items === "undefined") {
         this.messagePaginator.setItems({
           valueOrFactory: incomingReplies,
@@ -12907,16 +13079,9 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
       }
       this.addUnsubscribeFunction(this.subscribeThreadSetupStateChange());
       this.addUnsubscribeFunction(this.subscribeParentMessageFromStore());
-      this.addUnsubscribeFunction(this.subscribeThreadUpdated());
       this.addUnsubscribeFunction(this.subscribeMarkActiveThreadRead());
       this.addUnsubscribeFunction(this.subscribeReloadActiveStaleThread());
-      this.addUnsubscribeFunction(this.subscribeMarkThreadStale());
-      this.addUnsubscribeFunction(this.subscribeNewReplies());
-      this.addUnsubscribeFunction(this.subscribeRepliesRead());
-      this.addUnsubscribeFunction(this.subscribeRepliesUnread());
-      this.addUnsubscribeFunction(this.subscribeMessageDeleted());
-      this.addUnsubscribeFunction(this.subscribeMessageUpdated());
-      this.addUnsubscribeFunction(this.subscribeUserMessagesDeleted());
+      this.addUnsubscribeFunction(this.subscribeMarkStaleOnStopWatching());
     };
     /**
      * Subscribes this thread to the `'thread'` configuration key. Registered through
@@ -12933,10 +13098,10 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
      *   `hasLiveInstances('thread')` does not count it when deciding whether to warn about a
      *   construction-only path registered too late.
      *
-     * So read "declarative configuration is unaffected" as *at construction only*. A thread held by a
-     * `ThreadManager` that has itself registered is covered — `subscribeManageThreadSubscriptions` calls
-     * `registerSubscriptions()` on every thread entering its state — so the common path is fine. A thread
-     * constructed directly, or held by an unregistered manager, is not.
+     * So read "declarative configuration is unaffected" as *at construction only*. A thread registered
+     * with a `ThreadManager` that has itself registered is covered — the manager calls
+     * `registerSubscriptions()` on every thread the list holds or that is active — so the common path
+     * is fine. A thread that is neither, or held by an unregistered manager, is not.
      *
      * The alternative — applying the setup function at construction — would break the teardown symmetry
      * `WithSubscriptions` provides, which is why the asymmetry stands.
@@ -12952,7 +13117,7 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
       // on a change there, so the setup function's overrides survive.
       alsoWatch: ["messagePaginator", "messageOperations"]
     });
-    this.subscribeThreadUpdated = () => this.client.on("thread.updated", (event) => {
+    this.handleThreadUpdated = (event) => {
       if (!event.thread || event.thread.parent_message_id !== this.id) {
         return;
       }
@@ -12963,7 +13128,7 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
         deletedAt: threadData.deleted_at ?? null,
         custom: threadData.custom ?? {}
       });
-    }).unsubscribe;
+    };
     this.subscribeMarkActiveThreadRead = () => this.state.subscribeWithSelector(
       (nextValue) => ({
         active: nextValue.active,
@@ -12982,14 +13147,19 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
         }
       }
     );
-    this.subscribeMarkThreadStale = () => this.client.on("user.watching.stop", (event) => {
-      const { channel } = this.state.getLatestValue();
-      if (!this.client.userId || this.client.userId !== event.user?.id || event.channel?.cid !== channel.cid) {
-        return;
+    /**
+     * A watch stopped while the connection stays up (`NotWatching`) ends the channel's events with no
+     * reconnect to catch it. A dropped connection (`WasWatching`) is left to recovery.
+     */
+    this.subscribeMarkStaleOnStopWatching = () => this.channel.state.subscribeWithSelector(
+      ({ watchStatus }) => ({ watchStatus }),
+      ({ watchStatus }, previous) => {
+        if (previous?.watchStatus === ChannelWatchStatus.Watching && watchStatus === ChannelWatchStatus.NotWatching) {
+          this.state.partialNext({ isStateStale: true });
+        }
       }
-      this.state.partialNext({ isStateStale: true });
-    }).unsubscribe;
-    this.subscribeRepliesUnread = () => this.client.on("notification.mark_unread", (event) => {
+    );
+    this.handleRepliesUnread = (event) => {
       if (!event.user || event.created_at == null || !event.thread_id) return;
       if (event.thread_id !== this.id) return;
       const userId = event.user.id;
@@ -13008,8 +13178,8 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
           }
         }
       }));
-    }).unsubscribe;
-    this.subscribeNewReplies = () => this.client.on("message.new", (event) => {
+    };
+    this.handleNewReply = (event) => {
       if (!this.client.userId || event.message?.parent_id !== this.id) {
         return;
       }
@@ -13047,8 +13217,8 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
         }
       }
       this.state.partialNext({ read: nextRead });
-    }).unsubscribe;
-    this.subscribeRepliesRead = () => this.client.on("message.read", (event) => {
+    };
+    this.handleRepliesRead = (event) => {
       if (!event.user || event.created_at == null || !event.thread) return;
       if (event.thread.parent_message_id !== this.id) return;
       const userId = event.user.id;
@@ -13066,8 +13236,8 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
           }
         }
       }));
-    }).unsubscribe;
-    this.subscribeMessageDeleted = () => this.client.on("message.deleted", (event) => {
+    };
+    this.handleMessageDeleted = (event) => {
       if (!event.message) return;
       const formattedMessage = formatMessage(event.message);
       if (event.message.parent_id === this.id) {
@@ -13081,52 +13251,35 @@ var Thread = class extends WithMessageOperations(WithSubscriptions) {
         this.updateParentMessageLocally({ message: event.message });
       }
       this.messagePaginator.reflectQuotedMessageUpdate(formattedMessage);
-    }).unsubscribe;
-    this.subscribeMessageUpdated = () => {
-      const messageUpdateTypes = ["message.updated", "message.undeleted"];
-      const reactionTypes = [
-        "reaction.new",
-        "reaction.deleted",
-        "reaction.updated"
-      ];
-      const unsubscribeMessageUpdated = messageUpdateTypes.map(
-        (eventType) => this.client.on(eventType, (event) => {
-          if (!event.message) return;
-          const message = event.message.parent_id === this.id ? {
-            ...event.message,
-            own_reactions: this.messagePaginator.getItem(event.message.id)?.own_reactions ?? event.message.own_reactions
-          } : !event.message.parent_id && event.message.id === this.id ? {
-            ...event.message,
-            own_reactions: this.state.getLatestValue().parentMessage?.own_reactions ?? event.message.own_reactions
-          } : event.message;
-          this.updateParentMessageOrReplyLocally(message);
-          this.messagePaginator.reflectQuotedMessageUpdate(formatMessage(event.message));
-        }).unsubscribe
-      );
-      const unsubscribeReactions = reactionTypes.map(
-        (eventType) => this.client.on(eventType, (event) => {
-          if (!event.message || !event.reaction) return;
-          const { message } = event;
-          this.messagePaginator.reflectQuotedMessageUpdate(formatMessage(message));
-        }).unsubscribe
-      );
-      const unsubscribeFunctions = [...unsubscribeMessageUpdated, ...unsubscribeReactions];
-      return () => unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
     };
-    this.subscribeUserMessagesDeleted = () => {
-      const eventTypes = ["user.messages.deleted", "user.deleted"];
-      const unsubscribeFunctions = eventTypes.map(
-        (eventType) => this.client.on(eventType, (event) => {
-          if (!event.user) return;
-          const deletedAtSource = eventType === "user.deleted" ? event.user.deleted_at : event.created_at;
-          this.messagePaginator.applyMessageDeletionForUser({
-            userId: event.user.id,
-            hardDelete: !!event.hard_delete,
-            deletedAt: deletedAtSource ?? nowNs()
-          });
-        }).unsubscribe
-      );
-      return () => unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
+    this.handleMessageUpdated = (event) => {
+      if (!event.message) return;
+      const message = event.message.parent_id === this.id ? {
+        ...event.message,
+        own_reactions: this.messagePaginator.getItem(event.message.id)?.own_reactions ?? event.message.own_reactions
+      } : !event.message.parent_id && event.message.id === this.id ? {
+        ...event.message,
+        own_reactions: this.state.getLatestValue().parentMessage?.own_reactions ?? event.message.own_reactions
+      } : event.message;
+      this.updateParentMessageOrReplyLocally(message);
+      this.messagePaginator.reflectQuotedMessageUpdate(formatMessage(event.message));
+    };
+    this.handleReactionChanged = (event) => {
+      if (!event.message || !event.reaction) return;
+      const { message } = event;
+      this.messagePaginator.reflectQuotedMessageUpdate(formatMessage(message));
+    };
+    // Apply a user ban / deletion to this thread's own reply list. Previously
+    // channel.state.deleteUserMessages marked banned-user replies deleted in the (now removed)
+    // channel.state.threads shadow; the reply paginator is the thread's source of truth now.
+    this.handleUserMessagesDeleted = (event) => {
+      if (!event.user) return;
+      const deletedAtSource = event.type === "user.deleted" ? event.user.deleted_at : event.created_at;
+      this.messagePaginator.applyMessageDeletionForUser({
+        userId: event.user.id,
+        hardDelete: !!event.hard_delete,
+        deletedAt: deletedAtSource ?? nowNs()
+      });
     };
     // The parent message lives in the client-global message store (one canonical POJO per id);
     // `state.parentMessage` and the fields derived from it are a projection of that copy. Every update
@@ -14221,13 +14374,13 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
    *
    * Thread replies live in `thread.messagePaginator`, which is independent of the channel's, so
    * dispatching to the wrong one leaves the reply invisible where it was written. An edit composer
-   * is built from the message rather than from its thread, so it can only find the thread when the
-   * manager has it loaded. No composer reachable from a UI SDK is built that way today.
+   * is built from the message rather than from its thread, so it finds the thread only when
+   * `client.threads` has it registered — listed, or active (open somewhere).
    */
   get defaultSubmitTarget() {
     if (this.compositionContext instanceof Thread) return this.compositionContext;
     const { threadId } = this;
-    return threadId && this.client.threads.threadsById[threadId] || this.channel;
+    return threadId && this.client.threads.get(threadId) || this.channel;
   }
   /**
    * Whether submitting keeps the composer's contents rather than clearing them - see
@@ -17697,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,
@@ -17717,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)
     });
   }
@@ -17749,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;
   }
@@ -17803,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 {
@@ -17864,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;
@@ -18457,26 +18614,126 @@ var eventCarriesOwnUser = (event) => Object.hasOwn(event, "me");
 var DEFAULT_THREAD_MANAGER_CONFIG = deepFreezeConfig({
   connectionRecoveryThrottleMs: 1e3
 });
-var MAX_QUERY_THREADS_LIMIT = 25;
 var THREAD_MANAGER_INITIAL_STATE = {
   active: false,
-  wasActivatedAtLeastOnce: false,
   isThreadOrderStale: false,
-  threads: [],
   unreadThreadCount: 0,
   unseenThreadIds: [],
-  pagination: {
-    isLoading: false,
-    isLoadingNext: false,
-    nextCursor: null
-  },
-  ready: false
+  wasActivatedAtLeastOnce: false
 };
 var logger10 = chatLoggerSystem.getLogger("thread-manager");
+var getThreadId = (thread) => thread.id;
+var REGISTERED_HOLDER = { onEntitiesChanged: () => void 0 };
 var ThreadManager = class extends WithSubscriptions {
   constructor({ client }) {
     super();
+    /**
+     * Every live thread, held by the list (the paginator's own index over this store) and/or
+     * `REGISTERED_HOLDER` (opened this session). A thread leaves once neither holds it.
+     */
+    this.threadStore = new EntityStore({ getEntityId: getThreadId });
+    /** A reload is in flight; a second one is dropped (`master`'s `pagination.isLoading` guard). */
+    this.isReloadInFlight = false;
+    /**
+     * A local `pendingDisposal` listener (a state subscription, not a server watch) per channel instance
+     * that has had a listed or opened thread; removed when that channel is disposed or on reset.
+     */
+    this.disposalListeners = /* @__PURE__ */ new Map();
+    /**
+     * The live thread for `id`: one in the list, or one opened this session (e.g. from a message
+     * list). Resolve threads through this, not `paginator.items`, which is the list only; list
+     * membership is `paginator.getItem(id)`.
+     */
+    this.get = (id) => this.threadStore.get(id);
+    /**
+     * Returns the thread for `parentMessage`, creating it if it doesn't exist yet. Use this to open a
+     * thread instead of calling `new Thread()`.
+     *
+     * The returned thread is registered right away. If the thread list loads it before the UI
+     * activates it, the list reuses this instance instead of creating a duplicate.
+     *
+     * A thread created here only has its parent message, so it starts stale and it loads its thread data
+     * (participants, read state, replies) once, the first time it's opened.
+     */
+    this.ensure = ({
+      channel,
+      parentMessage
+    }) => {
+      let thread = this.threadStore.get(parentMessage.id);
+      if (!thread) {
+        thread = new Thread({ channel, client: this.client, parentMessage });
+        thread.state.partialNext({ isStateStale: true });
+      }
+      this.register(thread);
+      return thread;
+    };
+    /**
+     * Called by `thread.activate()`. Keeps `thread` for the session: it resolves through
+     * {@link ThreadManager.get} and stays subscribed whether or not the list holds it, until its
+     * channel is disposed or the user disconnects.
+     *
+     * @internal
+     */
+    this.register = (thread) => {
+      const { id } = thread;
+      const registered = this.threadStore.get(id);
+      if (registered && registered !== thread) {
+        logger10.withExtraTags("register").warn(
+          "Another instance of this thread is registered; this one stays unmanaged.",
+          {
+            threadId: id
+          }
+        );
+        return;
+      }
+      this.threadStore.link(id, REGISTERED_HOLDER);
+      this.threadStore.upsert(thread, REGISTERED_HOLDER);
+      if (this.hasSubscriptions) thread.registerSubscriptions();
+      this.listenForDisposal(thread);
+    };
+    /** Releases the `REGISTERED_HOLDER` hold on `thread`; the list's own diff unsubscribes it if it is still listed. */
+    this.release = (thread) => {
+      this.threadStore.unlink(thread.id, REGISTERED_HOLDER);
+      if (this.hasSubscriptions && !this.paginator.items?.includes(thread)) {
+        thread.unregisterSubscriptions();
+      }
+    };
+    /** Listens for its channel's disposal the first time a thread on that channel is seen. */
+    this.listenForDisposal = (thread) => {
+      const { channel } = thread;
+      if (this.disposalListeners.has(channel)) return;
+      if (channel.pendingDisposal) {
+        this.releaseChannel(channel);
+        return;
+      }
+      this.disposalListeners.set(
+        channel,
+        channel.state.subscribeWithSelector(
+          ({ pendingDisposal }) => ({ pendingDisposal }),
+          ({ pendingDisposal }) => {
+            if (pendingDisposal) this.releaseChannel(channel);
+          }
+        )
+      );
+    };
+    /** The channel was disposed, so its threads are unusable: release every one of them. */
+    this.releaseChannel = (channel) => {
+      this.disposalListeners.get(channel)?.();
+      this.disposalListeners.delete(channel);
+      const onChannel = (thread) => thread.channel === channel;
+      this.threadStore.values().filter(onChannel).forEach(this.release);
+      const listed = (this.paginator.items ?? []).filter(onChannel);
+      if (!listed.length) return;
+      this.paginator.batch(
+        () => listed.forEach(({ id }) => this.paginator.removeItem({ id })),
+        { coalesce: true }
+      );
+    };
     this.resetState = () => {
+      this.threadStore.values().forEach(this.release);
+      this.paginator.resetState();
+      this.disposalListeners.forEach((unsubscribe) => unsubscribe());
+      this.disposalListeners.clear();
       this.state.next(THREAD_MANAGER_INITIAL_STATE);
     };
     this.activate = () => {
@@ -18492,7 +18749,65 @@ var ThreadManager = class extends WithSubscriptions {
       this.addUnsubscribeFunction(this.subscribeReloadOnActivation());
       this.addUnsubscribeFunction(this.subscribeNewReplies());
       this.addUnsubscribeFunction(this.subscribeReloadOnConnectionRecovered());
-      this.addUnsubscribeFunction(this.subscribeChannelDeleted());
+      this.addUnsubscribeFunction(this.subscribeThreadEvents());
+      this.threadStore.values().forEach((thread) => thread.registerSubscriptions());
+    };
+    /**
+     * Hands client events to the threads in the store by id, as `PollManager` does for polls: a thread
+     * doesn't listen to the client itself. A message event goes to the thread the message is a reply
+     * in and the thread it starts; quoted-message updates stay within the reply's own thread, as on
+     * `master`. A thread follows its channel's `watchStatus` itself, so watch events need no routing.
+     */
+    this.subscribeThreadEvents = () => {
+      const threadsOf = (message) => message ? [
+        message.parent_id ? this.get(message.parent_id) : void 0,
+        this.get(message.id)
+      ] : [];
+      const unsubscribeFunctions = [
+        this.client.on("message.new", (event) => {
+          if (event.message?.parent_id)
+            this.get(event.message.parent_id)?.handleNewReply(event);
+        }),
+        this.client.on("message.read", (event) => {
+          if (event.thread)
+            this.get(event.thread.parent_message_id)?.handleRepliesRead(event);
+        }),
+        this.client.on("notification.mark_unread", (event) => {
+          if (event.thread_id) this.get(event.thread_id)?.handleRepliesUnread(event);
+        }),
+        this.client.on("thread.updated", (event) => {
+          if (event.thread)
+            this.get(event.thread.parent_message_id)?.handleThreadUpdated(event);
+        }),
+        this.client.on(
+          "message.deleted",
+          (event) => threadsOf(event.message).forEach((thread) => thread?.handleMessageDeleted(event))
+        ),
+        ...["message.updated", "message.undeleted"].map(
+          (eventType) => this.client.on(
+            eventType,
+            (event) => threadsOf(event.message).forEach(
+              (thread) => thread?.handleMessageUpdated(event)
+            )
+          )
+        ),
+        ...["reaction.new", "reaction.deleted", "reaction.updated"].map(
+          (eventType) => this.client.on(
+            eventType,
+            (event) => threadsOf(event.message).forEach(
+              (thread) => thread?.handleReactionChanged(event)
+            )
+          )
+        ),
+        // A banned or deleted user's replies can be in any thread, so these two are the exception.
+        ...["user.messages.deleted", "user.deleted"].map(
+          (eventType) => this.client.on(
+            eventType,
+            (event) => this.threadStore.values().forEach((thread) => thread.handleUserMessagesDeleted(event))
+          )
+        )
+      ].map(({ unsubscribe }) => unsubscribe);
+      return () => unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
     };
     this.subscribeUnreadThreadsCountChange = () => {
       const { unread_threads: unreadThreadCount = 0 } = this.client.user ?? {};
@@ -18514,18 +18829,13 @@ var ThreadManager = class extends WithSubscriptions {
       );
       return () => unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
     };
-    this.subscribeChannelDeleted = () => this.client.on("notification.channel_deleted", (event) => {
-      const { cid } = event;
-      const { threads } = this.state.getLatestValue();
-      const newThreads = threads.filter((thread) => thread.channel.cid !== cid);
-      this.state.partialNext({ threads: newThreads });
-    }).unsubscribe;
-    this.subscribeManageThreadSubscriptions = () => this.state.subscribeWithSelector(
-      (nextValue) => ({ threads: nextValue.threads }),
+    this.subscribeManageThreadSubscriptions = () => this.paginator.state.subscribeWithSelector(
+      (nextValue) => ({ threads: nextValue.items ?? [] }),
       ({ threads: nextThreads }, prev) => {
         const { threads: prevThreads = [] } = prev ?? {};
+        const listed = new Set(nextThreads);
         const removedThreads = prevThreads.filter(
-          (thread) => thread !== this.threadsById[thread.id]
+          (thread) => !listed.has(thread) && !this.threadStore.isHeldBy(thread.id, REGISTERED_HOLDER)
         );
         nextThreads.forEach((thread) => thread.registerSubscriptions());
         removedThreads.forEach((thread) => thread.unregisterSubscriptions());
@@ -18540,9 +18850,9 @@ var ThreadManager = class extends WithSubscriptions {
     this.subscribeNewReplies = () => this.client.on("notification.thread_message_new", (event) => {
       const parentId = event.message?.parent_id;
       if (!parentId) return;
-      const { unseenThreadIds, ready } = this.state.getLatestValue();
-      if (!ready) return;
-      if (this.threadsById[parentId]) {
+      if (!this.paginator.hasResults) return;
+      const { unseenThreadIds } = this.state.getLatestValue();
+      if (this.paginator.getItem(parentId)) {
         this.state.partialNext({ isThreadOrderStale: true });
       } else if (!unseenThreadIds.includes(parentId)) {
         this.state.partialNext({ unseenThreadIds: unseenThreadIds.concat(parentId) });
@@ -18569,94 +18879,33 @@ var ThreadManager = class extends WithSubscriptions {
       return this.client.on("connection.recovered", throttledHandleConnectionRecovered).unsubscribe;
     };
     this.unregisterSubscriptions = () => {
-      this.state.getLatestValue().threads.forEach((thread) => thread.unregisterSubscriptions());
+      this.threadStore.values().forEach((thread) => thread.unregisterSubscriptions());
       return super.unregisterSubscriptions();
     };
+    /**
+     * Loads the first page, or re-queries a loaded list in place, sized to what is loaded plus the
+     * unseen threads. Skipped once loaded unless forced or something changed; the list survives a
+     * failure. Guarded only against another reload, as on `master`. A reload of a loaded list shows
+     * no loading state; the first load shows through `paginator.isLoading`.
+     */
     this.reload = async ({ force = false } = {}) => {
-      const { threads, unseenThreadIds, isThreadOrderStale, pagination, ready } = this.state.getLatestValue();
-      if (pagination.isLoading) return;
-      if (!force && ready && !unseenThreadIds.length && !isThreadOrderStale) return;
-      const limit = threads.length + unseenThreadIds.length;
+      if (this.isReloadInFlight) return;
+      const { isThreadOrderStale, unseenThreadIds } = this.state.getLatestValue();
+      if (!force && this.paginator.hasResults && !unseenThreadIds.length && !isThreadOrderStale)
+        return;
+      const { items, pageSize } = this.paginator;
+      const limit = (items?.length ?? 0) + unseenThreadIds.length;
+      this.isReloadInFlight = true;
       try {
-        this.state.next((current) => ({
-          ...current,
-          pagination: {
-            ...current.pagination,
-            isLoading: true
-          }
-        }));
-        const response = await this.queryThreads({
-          limit: Math.min(limit, MAX_QUERY_THREADS_LIMIT) || MAX_QUERY_THREADS_LIMIT
-        });
-        const nextThreads = [];
-        for (const incomingThread of response.threads) {
-          const existingThread = this.threadsById[incomingThread.id];
-          if (existingThread) {
-            nextThreads.push(existingThread);
-            if (existingThread.hasStaleState) {
-              existingThread.hydrateState(incomingThread);
-            }
-          } else {
-            nextThreads.push(incomingThread);
-          }
+        await this.paginator.reload({ limit: Math.min(limit, pageSize) || pageSize });
+      } finally {
+        this.isReloadInFlight = false;
+        const error = this.paginator.lastQueryError;
+        if (error) {
+          logger10.withExtraTags("reload").error("Failed to reload the thread list.", { error });
+        } else {
+          this.state.partialNext({ isThreadOrderStale: false, unseenThreadIds: [] });
         }
-        this.state.next((current) => ({
-          ...current,
-          threads: nextThreads,
-          unseenThreadIds: [],
-          isThreadOrderStale: false,
-          pagination: {
-            ...current.pagination,
-            isLoading: false,
-            nextCursor: response.next ?? null
-          },
-          ready: true
-        }));
-      } catch (error) {
-        logger10.withExtraTags("reload").error("Failed to reload the thread list.", { error });
-        this.state.next((current) => ({
-          ...current,
-          pagination: {
-            ...current.pagination,
-            isLoading: false
-          }
-        }));
-      }
-    };
-    this.queryThreads = (options = {}) => this.client.queryThreadsAndHydrate({
-      limit: 25,
-      participant_limit: 10,
-      reply_limit: 10,
-      watch: true,
-      ...options
-    });
-    this.loadNextPage = async (options = {}) => {
-      const { pagination } = this.state.getLatestValue();
-      if (pagination.isLoadingNext || !pagination.nextCursor) return;
-      try {
-        this.state.partialNext({ pagination: { ...pagination, isLoadingNext: true } });
-        const response = await this.queryThreads({
-          ...options,
-          next: pagination.nextCursor
-        });
-        this.state.next((current) => ({
-          ...current,
-          threads: response.threads.length ? current.threads.concat(response.threads) : current.threads,
-          pagination: {
-            ...current.pagination,
-            nextCursor: response.next ?? null,
-            isLoadingNext: false
-          }
-        }));
-      } catch (error) {
-        logger10.withExtraTags("loadNextPage").error("Failed to load the next page of threads.", { error });
-        this.state.next((current) => ({
-          ...current,
-          pagination: {
-            ...current.pagination,
-            isLoadingNext: false
-          }
-        }));
       }
     };
     this.configController = new ConfigController({
@@ -18664,7 +18913,11 @@ var ThreadManager = class extends WithSubscriptions {
     });
     this.client = client;
     this.state = new import_state_store21.StateStore(THREAD_MANAGER_INITIAL_STATE);
-    this.threadsByIdGetterCache = { threads: [], threadsById: {} };
+    this.paginator = new ThreadPaginator({ client, store: this.threadStore });
+    this.paginator.state.subscribeWithSelector(
+      ({ items }) => ({ items }),
+      ({ items }) => items?.forEach(this.listenForDisposal)
+    );
   }
   /**
    * Resolved configuration, as a store — the shape every configurable class exposes
@@ -18698,21 +18951,13 @@ var ThreadManager = class extends WithSubscriptions {
   initializeConfig(config) {
     this.configController.initialize(config);
   }
-  get threadsById() {
-    const { threads } = this.state.getLatestValue();
-    if (threads === this.threadsByIdGetterCache.threads) {
-      return this.threadsByIdGetterCache.threadsById;
-    }
-    const threadsById = threads.reduce(
-      (newThreadsById, thread) => {
-        newThreadsById[thread.id] = thread;
-        return newThreadsById;
-      },
-      {}
-    );
-    this.threadsByIdGetterCache.threads = threads;
-    this.threadsByIdGetterCache.threadsById = threadsById;
-    return threadsById;
+  /**
+   * Every registered thread — the list's plus the opened ones.
+   *
+   * @internal
+   */
+  get registeredThreads() {
+    return this.threadStore.values();
   }
 };
 
@@ -20096,6 +20341,7 @@ var ConnectionRecoveryManager = class extends WithSubscriptions {
       }
       const channels = this.recoverableActiveChannels;
       const threads = this.recoverableActiveThreads;
+      this.markInactiveThreadsStale();
       const socketDropBefore = this.client.wsConnection.state.getLatestValue().lastUnhealthyAt;
       this.isRecovering = true;
       logger12.withExtraTags("connectionRecovery").info(
@@ -20182,41 +20428,34 @@ var ConnectionRecoveryManager = class extends WithSubscriptions {
    * Threads need their own pass because nothing else brings an open thread's replies back — a
    * channel reload refreshes the main message list, `ChannelManager.recover()` refreshes the channel
    * lists*, and `ThreadManager`'s own recovery refreshes the thread *list*, reusing existing
-   * instances without rehydrating them unless they were separately marked stale (which only
-   * `user.watching.stop` does, never a reconnect).
+   * instances without rehydrating them unless they were separately marked stale.
    *
-   * `active` is the filter that matters: `threadsById` holds every thread the list has paged in,
-   * which is not what should be re-fetched on a reconnect — only what someone is actually reading.
+   * `active` is the filter that matters: the registry also holds every thread the list has paged
+   * in, which is not what should be re-fetched on a reconnect — only what someone is actually
+   * reading. An active thread is always registered, listed or not (`thread.activate()` registers it).
    * Guarded on the owning channel the same way active channels are: a thread whose channel is being
    * torn down has nothing to recover into.
-   *
-   * NOTE: `threadsById` is the thread LIST, not a thread cache. A thread opened from a message list
-   * is constructed directly (`threadsById[id] ?? new Thread(...)`) and only reaches the list because
-   * the UI SDKs adopt it there — prepended, once its replies have loaded — which is a workaround, not
-   * a contract. Two consequences, both accepted for now and both narrow:
-   *
-   * - A reconnect landing before that adoption misses the thread. Self-limiting: the UI SDKs re-issue
-   *   the load while the reply list is still unloaded, so a thread that failed to load gets adopted on
-   *   the retry.
-   * - `ThreadManager.reload()` rebuilds `state.threads` purely from the query response, so an adopted
-   *   thread absent from that response is evicted while still active. It cannot bite within the
-   *   reconnect that caused it: this getter is read before `connection.recovered` is dispatched, and
-   *   that event is what triggers the UI SDKs' list reload. It would take a LATER reconnect, after an
-   *   eviction, to miss the thread.
-   *
-   * The fix is a real off-list registry — see the commented-out `threadCache` in `ThreadManager` — at
-   * which point this getter reads from that instead, with no change to the `active` filter.
    */
   get recoverableActiveThreads() {
     const threads = [];
-    for (const thread of Object.values(this.client.threads.threadsById)) {
-      if (!thread) continue;
+    for (const thread of this.client.threads.registeredThreads) {
       const { active } = thread.state.getLatestValue();
       if (!active || thread.channel.pendingDisposal) continue;
       threads.push(thread);
     }
     return threads;
   }
+  /**
+   * An opened thread stays registered and subscribed after it closes, but a drop loses events it
+   * cannot replay. Flag only, no request: a listed one is rehydrated by the thread list's reload,
+   * and any other reloads on its next `activate()`.
+   */
+  markInactiveThreadsStale() {
+    for (const thread of this.client.threads.registeredThreads) {
+      const { active, isStateStale } = thread.state.getLatestValue();
+      if (!active && !isStateStale) thread.state.partialNext({ isStateStale: true });
+    }
+  }
 };
 
 // src/connection/networkConnection/NetworkConnectionObserver.ts
@@ -20348,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
@@ -20399,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,
@@ -20986,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();
@@ -21012,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) {
@@ -21020,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);
             }
           )
         );
@@ -21073,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] }
       );
@@ -21092,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
    */
@@ -21130,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
@@ -21156,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,
@@ -21659,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() {
     /**
@@ -21857,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);
       }
     }
   }
@@ -21915,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."
     );
   }
@@ -21942,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().`
     );
   }
@@ -23293,6 +23766,7 @@ var ChatApi = class {
   }
   async longPoll(request, requestOptions) {
     const queryParams = {
+      close: request?.close,
       connection_id: request?.connection_id,
       json: request?.json
     };
@@ -23905,8 +24379,11 @@ 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;
+};
 var StreamChat = class _StreamChat extends ChatApi {
   /**
    * Initializes a client.
@@ -23961,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;
@@ -23972,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.'
         );
       }
@@ -24018,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();
@@ -24043,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.
      */
@@ -24054,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()}`;
@@ -24115,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(
@@ -24123,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();
       }
@@ -24138,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;
     };
@@ -24158,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.'
         );
       }
@@ -24311,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);
       }
     };
     /**
@@ -24322,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) {
@@ -24420,7 +24903,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.15";
+        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 ?? {};
@@ -24450,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"]
@@ -24477,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,
@@ -24734,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);
@@ -24752,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) {
@@ -24762,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);
     }
@@ -24839,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) {
@@ -24891,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.
@@ -24915,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`.
@@ -25369,12 +25883,11 @@ var StreamChat = class _StreamChat extends ChatApi {
     const response = await this.queryThreads(requestBody, requestOptions);
     const parentMessages = response.threads.map((thread) => thread.parent_message);
     this.polls.hydratePollCache(parentMessages);
-    return {
-      threads: response.threads.map(
-        (thread) => new Thread({ client: this, threadData: thread })
-      ),
-      next: response.next
-    };
+    const threads = response.threads.map(
+      (thread) => new Thread({ client: this, threadData: thread })
+    );
+    if (optionsWithDefaults.watch) threads.forEach(markThreadChannelWatched);
+    return { threads, next: response.next };
   }
   /**
    * Returns the thread of a message by its ID, wrapped in a hydrated `Thread` instance.
@@ -25406,7 +25919,9 @@ var StreamChat = class _StreamChat extends ChatApi {
       },
       requestOptions
     );
-    return new Thread({ client: this, threadData: response.thread });
+    const thread = new Thread({ client: this, threadData: response.thread });
+    if (optionsWithDefaults.watch) markThreadChannelWatched(thread);
+    return thread;
   }
   /**
    * Sets the user agent string.
@@ -25841,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",
@@ -25899,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"
   }
@@ -26123,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,
@@ -26168,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 });
       }
     };
     /**
@@ -26258,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 {
@@ -26278,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;
@@ -26319,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,
@@ -26344,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 });
       }
     };
     /**
@@ -26436,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 }
         );
@@ -26447,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 }
         );
@@ -26642,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 = [
@@ -27057,13 +27577,12 @@ var AbstractOfflineDB = class {
      * message ordered against everything queued after it.
      *
      * Keyed on a queued `send-message` task existing for this id - the only reliable statement of "the
-     * server has never seen this message". NOT on the edited message's status: both payloads are built
-     * by `localMessageToNewMessagePayload`, which strips `status` along with every other client-only
-     * field, so nothing arriving here carries one.
+     * server has never seen this message". NOT on the edited message's status: `failed` is also what a
+     * rejected edit of a message the server has carries.
      *
-     * That same normalization is why the two merge by a plain spread: both are already `MessageRequest`s,
-     * and normalizing again would map an already-flattened `mentioned_users` back over itself as
-     * `[undefined]`.
+     * Both payloads are already `MessageRequest`s (the send's from `localMessageToNewMessagePayload`, the
+     * edit's from `toUpdatedMessagePayload`), which is why they merge by a plain spread: normalizing again
+     * would map an already-flattened `mentioned_users` back over itself as `[undefined]`.
      *
      * With nothing to fold into, the edit is queued on its own and replays as an ordinary update.
      */