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

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,
@@ -552,7 +555,7 @@ var channelHasReadEvents = (channel) => {
   const ownCapabilities = channel?.data?.own_capabilities;
   return !(Array.isArray(ownCapabilities) && !ownCapabilities.includes("read-events"));
 };
-var channelTracksReadLocally = (channel) => !channelHasReadEvents(channel) && !!channel?.getClient().options.isLocalUnreadCountEnabled;
+var channelTracksReadLocally = (channel) => !channelHasReadEvents(channel) && !!channel?.config.readEvents.localUnreadCountEnabled;
 function retryInterval(numberOfFailures) {
   const max = Math.min(500 + numberOfFailures * 2e3, 25e3);
   const min = Math.min(Math.max(250, (numberOfFailures - 1) * 2e3), 25e3);
@@ -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
         });
@@ -8153,6 +8182,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 +8240,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 +8408,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 +8460,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 +9062,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 +12785,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 +12830,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 +12941,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 +12971,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 +13057,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 +13076,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 +13095,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 +13114,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 +13125,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 +13144,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 +13175,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 +13214,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 +13233,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 +13248,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 +14371,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
@@ -14478,11 +14628,12 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
       }, this.requestTimeoutMs);
     };
     /**
-     * Delegates the mark-read call to the Channel or Thread instance.
+     * Delegates the mark-read call to the Channel or Thread instance. A channel whose read events are
+     * disabled is marked read locally instead, when the client opted into counting unread itself.
      *
      * @param collection - The channel or thread to mark as read.
      * @param options - Flags forwarded to the underlying `markRead` call (optional).
-     * @returns The server response, or `null` when the collection is unsupported.
+     * @returns The server response, or `null` when no request went out.
      */
     this.markRead = async (collection, options) => {
       const isThreadCollection = isThread(collection);
@@ -14496,8 +14647,15 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
           thread: collection
         }) ?? null : await channel.markRead(requestOptions);
       } else {
-        const markReadRequestHandler = channel.configState.getLatestValue().requestHandlers?.markReadRequest;
-        result = markReadRequestHandler ? await markReadRequestHandler({ channel, options: requestOptions }) ?? null : await channel.markRead(requestOptions);
+        const { readEvents, requestHandlers } = channel.configState.getLatestValue();
+        const markReadRequestHandler = requestHandlers?.markReadRequest;
+        if (markReadRequestHandler) {
+          result = await markReadRequestHandler({ channel, options: requestOptions }) ?? null;
+        } else if (!readEvents.enabled && readEvents.localUnreadCountEnabled) {
+          channel.markReadLocally();
+        } else {
+          result = await channel.markRead(requestOptions);
+        }
       }
       if (result) this.removeCandidateFor(collection);
       return result;
@@ -15451,7 +15609,7 @@ var ownDeclarativeConfig = (slice) => {
 var DEFAULT_CHANNEL_CONFIG = deepFreezeConfig({
   availableCommands: [],
   deliveryEvents: { enabled: true },
-  readEvents: { enabled: true },
+  readEvents: { enabled: true, localUnreadCountEnabled: false },
   replies: { enabled: true },
   typingEvents: { enabled: true },
   userMessageReminders: { enabled: true }
@@ -16478,7 +16636,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
   /**
    * Resets this user's unread count locally, without any backend call. Intended for
    * channels that have read events disabled (e.g. livestreams) when the client is created with the
-   * `isLocalUnreadCountEnabled` option. Dispatches a dedicated, client-only `message.read_locally` event
+   * `readEvents.localUnreadCountEnabled` configuration. Dispatches a dedicated, client-only `message.read_locally` event
    * that runs through the same `_handleChannelEvent` read logic as a real `message.read` (minus the
    * delivery-report network sync), so the read-state update lives in one place. When offline support
    * is enabled, the offline DB persists the reset for read-events-disabled channels, so the local
@@ -16640,7 +16798,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
     if (message.user?.id === this.getClient().userId) return false;
     if (message.user?.id && this.getClient().userMuteStatus(message.user.id))
       return false;
-    if (!this.getClient().options.isLocalUnreadCountEnabled && !channelHasReadEvents(this)) {
+    if (!this.config.readEvents.localUnreadCountEnabled && !channelHasReadEvents(this)) {
       return false;
     }
     if (this.muteStatus().muted) return false;
@@ -18449,26 +18607,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 = () => {
@@ -18484,7 +18742,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 ?? {};
@@ -18506,18 +18822,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());
@@ -18532,9 +18843,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) });
@@ -18561,94 +18872,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({
@@ -18656,7 +18906,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
@@ -18690,21 +18944,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();
   }
 };
 
@@ -20088,6 +20334,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(
@@ -20174,41 +20421,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
@@ -23899,6 +24139,9 @@ function isString(value) {
 }
 var logger17 = 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.
@@ -24412,7 +24655,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.14";
+        const version = "10.0.0-rc.16";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -24468,10 +24711,7 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.uploadManager = new UploadManager(this);
     this.browser = options.browser ?? typeof window !== "undefined";
     this.node = !this.browser;
-    this.options = {
-      isLocalUnreadCountEnabled: false,
-      ...options
-    };
+    this.options = { ...options };
     this.axiosInstance = import_axios4.default.create({
       timeout: 3e3,
       withCredentials: false,
@@ -25364,12 +25604,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.
@@ -25401,7 +25640,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.
@@ -25961,6 +26202,11 @@ var CHANNEL_FIELDS = {
         description: 'Allows marking the channel read or unread. The server must also allow it per channel type (`read_events`), and a server "no" wins.',
         kind: "value",
         type: "boolean"
+      },
+      localUnreadCountEnabled: {
+        description: "Counts unread messages client-side when `enabled` is false, reset by `channel.markReadLocally()` instead of a request. Not subject to server authority.",
+        kind: "value",
+        type: "boolean"
       }
     },
     kind: "group"
@@ -27047,13 +27293,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.
      */