From 86de0baf1af94b32fe4b7c77f19de6c052f44629 Mon Sep 17 00:00:00 2001
From: Oliver Lazoroski <oliver.lazoroski@gmail.com>
Date: Sat, 17 Oct 2026 01:00:17 +0200
Subject: [PATCH 1/5] fix: remove dead v15 surface and restore v14 behaviors
 found by the API audit

Removes props and slots that v15 types still declared but nothing read:
MessageList's messages, hasMore, jumpToLatestMessage, loadingMoreNewer and
messageLimit, VirtualizedMessageList's messages, CustomClasses.chatContainer,
ComponentContext.LoadingErrorIndicator, the channel-list-inner SCSS rules and
commented-out ChannelUnreadUiState leftovers.

Restores behavior lost in the move to stream-chat v10:
- MessageList shows its loading indicator while an older page loads
- ChannelNavigation carries the str-chat theme scope and customClasses.channelList
- channel-detail DM and pinned-message actions open via workspace navigation
- the reply-count button honors Message.openThread
- the gallery header renders a MessageTimestamp override
- navigation without a provider warns once per operation

Exports useIsCooldownActive and useMessagePaginator from the package root.
---
 src/components/Attachment/ModalGallery.tsx    |  3 +-
 .../hooks/useChannelContainerClasses.ts       |  4 -
 src/components/ChannelList/ChannelList.tsx    |  2 +-
 .../ChannelList/ChannelNavigation.tsx         | 18 +++-
 .../__tests__/ChannelNavigation.test.tsx      | 67 +++++++++++++++
 .../ChannelList/styling/ChannelList.scss      | 14 ---
 src/components/Gallery/GalleryContext.tsx     |  7 +-
 src/components/Gallery/GalleryHeader.tsx      | 13 ++-
 .../Gallery/__tests__/GalleryUI.test.tsx      | 61 +++++++++++++
 .../Message/MessageRepliesCountButton.tsx     | 10 ++-
 src/components/Message/MessageTimestamp.tsx   |  8 +-
 .../MessageRepliesCountButton.test.tsx        | 69 ++++++++++++++-
 .../__tests__/useIsCooldownActive.test.tsx    | 50 +++++++++++
 src/components/MessageComposer/hooks/index.ts |  1 +
 src/components/MessageList/MessageList.tsx    | 34 ++------
 .../MessageList/VirtualizedMessageList.tsx    | 43 ----------
 .../__tests__/MessageList.test.tsx            | 85 ++++++++++++++++++-
 src/components/MessageList/renderMessages.tsx |  1 -
 src/context/ChannelListContext.tsx            |  2 +-
 src/context/ChatContext.tsx                   |  1 -
 src/context/ComponentContext.tsx              |  3 -
 src/context/WorkspaceNavigationContext.tsx    | 36 +++++++-
 .../WorkspaceNavigationContext.test.tsx       | 54 ++++++++++++
 .../__tests__/useMessagePaginator.test.tsx    | 53 ++++++++++++
 src/index.ts                                  |  1 +
 .../ChannelMediaView.utils.ts                 |  4 +
 .../ChannelMemberActions.defaults.tsx         | 15 ++--
 .../SendDirectMessageAction.test.tsx          | 19 ++---
 .../PinnedMessagesView/PinnedMessagesView.tsx | 10 +--
 .../__tests__/PinnedMessagesView.test.tsx     | 25 ++++++
 src/types/index.ts                            |  1 -
 src/types/types.ts                            |  2 -
 32 files changed, 581 insertions(+), 135 deletions(-)
 create mode 100644 src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
 create mode 100644 src/components/MessageComposer/hooks/__tests__/useIsCooldownActive.test.tsx
 create mode 100644 src/hooks/__tests__/useMessagePaginator.test.tsx

diff --git a/src/components/Attachment/ModalGallery.tsx b/src/components/Attachment/ModalGallery.tsx
index 3e64782ada..92615d337d 100644
--- a/src/components/Attachment/ModalGallery.tsx
+++ b/src/components/Attachment/ModalGallery.tsx
@@ -71,9 +71,10 @@ export const ModalGallery = ({
       items.map((item) => ({
         ...item,
         createdAt: item.createdAt ?? convertTimestampToDate(message?.created_at),
+        message: item.message ?? message,
         user: item.user ?? message?.user ?? undefined,
       })),
-    [items, message?.created_at, message?.user],
+    [items, message],
   );
   const usesDefaultBaseImage = BaseImage === DefaultBaseImage;
 
diff --git a/src/components/Channel/hooks/useChannelContainerClasses.ts b/src/components/Channel/hooks/useChannelContainerClasses.ts
index 14fceaa45b..91804a46d6 100644
--- a/src/components/Channel/hooks/useChannelContainerClasses.ts
+++ b/src/components/Channel/hooks/useChannelContainerClasses.ts
@@ -8,9 +8,6 @@ export const useImageFlagEmojisOnWindowsClass = () => {
     : '';
 };
 
-export const getChatContainerClass = (customClass?: string) =>
-  customClass ?? 'str-chat__container';
-
 export const useChannelContainerClasses = ({
   customClasses,
 }: Pick<ChatContextValue, 'customClasses'>) => {
@@ -18,7 +15,6 @@ export const useChannelContainerClasses = ({
   return {
     channelClass: customClasses?.channel ?? 'str-chat__channel',
     chatClass: customClasses?.chat ?? 'str-chat',
-    chatContainerClass: getChatContainerClass(customClasses?.chatContainer),
     windowsEmojiClass,
   };
 };
diff --git a/src/components/ChannelList/ChannelList.tsx b/src/components/ChannelList/ChannelList.tsx
index 3c99d1fd0a..d6b802c93c 100644
--- a/src/components/ChannelList/ChannelList.tsx
+++ b/src/components/ChannelList/ChannelList.tsx
@@ -92,7 +92,7 @@ export const ChannelList = ({
       ListItem={ListItem as ComponentType<{ item: Channel }>}
       LoadingNextPageIndicator={LoadingNextPageIndicator}
       loadNextDebounceMs={loadMoreDebounceMs}
-      loadNextOnScrollToBottom={paginator.next}
+      loadNextOnScrollToBottom={paginator.toTail}
       onClickCapture={onClickCapture}
       onKeyDown={onKeyDown}
       paginator={paginator}
diff --git a/src/components/ChannelList/ChannelNavigation.tsx b/src/components/ChannelList/ChannelNavigation.tsx
index 27bbc63e5f..d05d94b0af 100644
--- a/src/components/ChannelList/ChannelNavigation.tsx
+++ b/src/components/ChannelList/ChannelNavigation.tsx
@@ -1,3 +1,4 @@
+import clsx from 'clsx';
 import React from 'react';
 import type { SearchControllerState } from 'stream-chat';
 
@@ -6,6 +7,7 @@ import { ChannelLists } from './ChannelLists';
 import { NotificationList as DefaultNotificationList } from '../Notifications';
 import { Search as DefaultSearch } from '../Search';
 import { useChatContext, useComponentContext } from '../../context';
+import { useImageFlagEmojisOnWindowsClass } from '../Channel/hooks/useChannelContainerClasses';
 import { useStateStore } from '../../store';
 
 const searchControllerStateSelector = (state: SearchControllerState) => ({
@@ -18,6 +20,10 @@ const searchControllerStateSelector = (state: SearchControllerState) => ({
  * always; results while active), then the paginator-driven `ChannelLists` only while
  * search is inactive. Mapped to the channel-navigation slot; `Search` is customizable
  * via the `ComponentContext` `Search` slot.
+ *
+ * Its root carries the `str-chat` theme scope itself (like `Channel`), so the design tokens apply
+ * when it is rendered outside `ChatView`. `customClasses.chat` / `customClasses.channelList`
+ * replace the `str-chat` / `str-chat__channel-list` classes.
  */
 export const ChannelNavigation = () => {
   const {
@@ -25,14 +31,22 @@ export const ChannelNavigation = () => {
     NotificationList = DefaultNotificationList,
     Search = DefaultSearch,
   } = useComponentContext();
-  const { searchController } = useChatContext();
+  const { customClasses, searchController, theme } = useChatContext();
+  const windowsEmojiClass = useImageFlagEmojisOnWindowsClass();
   const { isActive } = useStateStore(
     searchController.state,
     searchControllerStateSelector,
   );
 
   return (
-    <div className='str-chat__channel-list'>
+    <div
+      className={clsx(
+        customClasses?.chat ?? 'str-chat',
+        theme,
+        customClasses?.channelList ?? 'str-chat__channel-list',
+        windowsEmojiClass,
+      )}
+    >
       <ChannelListHeader />
       <Search />
       {!isActive && <ChannelLists />}
diff --git a/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx b/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
new file mode 100644
index 0000000000..db850b778c
--- /dev/null
+++ b/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
@@ -0,0 +1,67 @@
+import React from 'react';
+import { cleanup, render } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { StreamChat } from 'stream-chat';
+
+import { Chat } from '../../Chat';
+import type { ChatProps } from '../../Chat';
+import { ChannelNavigation } from '../ChannelNavigation';
+import { getTestClientWithUser } from '../../../mock-builders';
+import { axe } from '../../../../axe-helper';
+
+const setupClient = async () => {
+  const client = await getTestClientWithUser({ id: 'user_x' });
+  // no paginator is registered, so nothing should query
+  vi.spyOn(client, 'queryChannelsAndHydrate').mockRejectedValue(
+    new Error('unexpected channel query'),
+  );
+  return client;
+};
+
+const renderNavigation = (
+  client: StreamChat,
+  chatProps: Partial<Omit<ChatProps, 'client'>> = {},
+) =>
+  render(
+    <Chat client={client} {...chatProps}>
+      <ChannelNavigation />
+    </Chat>,
+  );
+
+describe('ChannelNavigation', () => {
+  afterEach(cleanup);
+
+  it('carries the str-chat theme scope on its root outside ChatView', async () => {
+    const client = await setupClient();
+
+    const { container } = renderNavigation(client, { theme: 'str-chat__theme-dark' });
+
+    const root = container.firstElementChild;
+    expect(root).toHaveClass(
+      'str-chat',
+      'str-chat__theme-dark',
+      'str-chat__channel-list',
+    );
+  });
+
+  it('applies customClasses.chat and customClasses.channelList to its root', async () => {
+    const client = await setupClient();
+
+    const { container } = renderNavigation(client, {
+      customClasses: { channelList: 'custom-channel-list', chat: 'custom-chat' },
+    });
+
+    const root = container.firstElementChild;
+    expect(root).toHaveClass('custom-chat', 'custom-channel-list');
+    expect(root).not.toHaveClass('str-chat');
+    expect(root).not.toHaveClass('str-chat__channel-list');
+  });
+
+  it('has no axe violations', async () => {
+    const client = await setupClient();
+
+    const { container } = renderNavigation(client);
+
+    expect(await axe(container)).toHaveNoViolations();
+  });
+});
diff --git a/src/components/ChannelList/styling/ChannelList.scss b/src/components/ChannelList/styling/ChannelList.scss
index 23ac4d1614..fe1c5eb5c9 100644
--- a/src/components/ChannelList/styling/ChannelList.scss
+++ b/src/components/ChannelList/styling/ChannelList.scss
@@ -45,20 +45,6 @@
   color: var(--str-chat__text-primary);
   border-inline-end: 1px solid var(--str-chat__border-core-default);
 
-  .str-chat__channel-list-inner {
-    flex: 1;
-    min-height: 0;
-    overflow: hidden;
-    padding-bottom: calc(var(--str-chat__space-8) + var(--str-chat__space-2));
-
-    .str-chat__channel-list-inner__main {
-      height: 100%;
-      overflow-y: auto;
-      scrollbar-gutter: stable both-edges;
-      scrollbar-width: thin;
-    }
-  }
-
   .str-chat__load-more-button {
     display: flex;
     justify-content: center;
diff --git a/src/components/Gallery/GalleryContext.tsx b/src/components/Gallery/GalleryContext.tsx
index a03adb1ba2..b2edce519b 100644
--- a/src/components/Gallery/GalleryContext.tsx
+++ b/src/components/Gallery/GalleryContext.tsx
@@ -1,5 +1,5 @@
 import { createContext, useContext } from 'react';
-import type { UserResponse } from 'stream-chat';
+import type { LocalMessage, UserResponse } from 'stream-chat';
 
 import { requireContext } from '../../context/requireContext';
 import { toBaseImageDescriptors } from '../BaseImage';
@@ -11,6 +11,11 @@ export type GalleryItem = Omit<BaseImageProps, 'src'> & {
   createdAt?: string | Date;
   dimensions?: Dimensions;
   imageUrl?: string;
+  /**
+   * The message the media was shared in. Lets the gallery header render a `MessageTimestamp`
+   * override from `ComponentContext` for it.
+   */
+  message?: LocalMessage;
   /** User who shared the media; drives the gallery header title. */
   user?: UserResponse;
   videoThumbnailUrl?: string;
diff --git a/src/components/Gallery/GalleryHeader.tsx b/src/components/Gallery/GalleryHeader.tsx
index 8d684fe899..811017ae2d 100644
--- a/src/components/Gallery/GalleryHeader.tsx
+++ b/src/components/Gallery/GalleryHeader.tsx
@@ -6,6 +6,7 @@ import { Button } from '../Button';
 import {
   ModalContext,
   useChatContext,
+  useComponentContext,
   useComponentContextIcons,
   useTranslationContext,
 } from '../../context';
@@ -50,10 +51,11 @@ const GalleryTimestamp = ({ createdAt }: Pick<GalleryItem, 'createdAt'>) => {
 
 export const GalleryHeader = ({ currentItem }: GalleryHeaderProps) => {
   const { IconArrowDownCircle, IconXmark } = useComponentContextIcons();
+  const { MessageTimestamp } = useComponentContext();
   const { t } = useTranslationContext();
   const { client } = useChatContext();
   const modalContext = useContext(ModalContext);
-  const { createdAt, user } = currentItem;
+  const { createdAt, message, user } = currentItem;
 
   const headerTitle =
     (!!user?.id && user.id === client.userID && t('common.you.label', 'You')) ||
@@ -77,7 +79,14 @@ export const GalleryHeader = ({ currentItem }: GalleryHeaderProps) => {
       <div aria-hidden='true' className='str-chat__gallery__header-spacer' />
       <div className='str-chat__gallery__header-meta'>
         <div className='str-chat__gallery__title'>{headerTitle}</div>
-        <GalleryTimestamp createdAt={createdAt} />
+        {MessageTimestamp && message ? (
+          <MessageTimestamp
+            customClass='str-chat__gallery__timestamp'
+            message={message}
+          />
+        ) : (
+          <GalleryTimestamp createdAt={createdAt} />
+        )}
       </div>
       <div className='str-chat__gallery__header-actions'>
         {downloadUrl ? (
diff --git a/src/components/Gallery/__tests__/GalleryUI.test.tsx b/src/components/Gallery/__tests__/GalleryUI.test.tsx
index 72d8fce22e..c51a7ef7f4 100644
--- a/src/components/Gallery/__tests__/GalleryUI.test.tsx
+++ b/src/components/Gallery/__tests__/GalleryUI.test.tsx
@@ -7,7 +7,11 @@ import {
   ChatProvider,
   ModalContextProvider,
   TranslationProvider,
+  WithComponents,
 } from '../../../context';
+import { MessageTimestamp as DefaultMessageTimestamp } from '../../Message/MessageTimestamp';
+import type { MessageTimestampProps } from '../../Message/MessageTimestamp';
+import { generateMessage } from '../../../mock-builders';
 import {
   mockChatContext,
   mockTranslationContextValue,
@@ -49,10 +53,12 @@ const getSlideContainer = (container: HTMLElement) => {
 const renderGalleryUI = (
   items: GalleryItem[],
   {
+    components,
     galleryProps,
     initialIndex = 0,
     modalContext,
   }: {
+    components?: React.ComponentProps<typeof WithComponents>['overrides'];
     galleryProps?: Partial<GalleryProps>;
     initialIndex?: number;
     modalContext?: ModalContextValue;
@@ -73,6 +79,10 @@ const renderGalleryUI = (
     );
   }
 
+  if (components) {
+    children = <WithComponents overrides={components}>{children}</WithComponents>;
+  }
+
   return render(
     <ChatProvider value={mockChatContext({ client: { userID: CURRENT_USER_ID } })}>
       <TranslationProvider value={mockTranslationContextValue()}>
@@ -270,6 +280,57 @@ describe('GalleryUI', () => {
       expect(screen.queryByText('You')).not.toBeInTheDocument();
     });
 
+    it('should render the MessageTimestamp override for the item message', () => {
+      const message = generateMessage({ user: { id: 'jenny', name: 'Jenny' } });
+      const CustomMessageTimestamp = (props: MessageTimestampProps) => (
+        <span className={props.customClass} data-testid='custom-message-timestamp'>
+          {props.message?.id}
+        </span>
+      );
+      const items = [
+        makeImageItem({
+          createdAt: new Date('2025-01-01T12:34:56.000Z'),
+          message,
+          user: { id: 'jenny', name: 'Jenny' },
+        }),
+      ];
+
+      renderGalleryUI(items, {
+        components: { MessageTimestamp: CustomMessageTimestamp },
+      });
+
+      const timestamp = screen.getByTestId('custom-message-timestamp');
+      expect(timestamp).toHaveTextContent(message.id);
+      expect(timestamp).toHaveClass('str-chat__gallery__timestamp');
+    });
+
+    it('should render the default MessageTimestamp from the item message outside a message', () => {
+      // The gallery renders outside any MessageProvider; the timestamp reads the item's message.
+      const message = generateMessage({ user: { id: 'jenny', name: 'Jenny' } });
+      const items = [makeImageItem({ message, user: { id: 'jenny', name: 'Jenny' } })];
+
+      const { container } = renderGalleryUI(items, {
+        components: { MessageTimestamp: DefaultMessageTimestamp },
+      });
+
+      expect(
+        container.querySelector('.str-chat__gallery__timestamp'),
+      ).toBeInTheDocument();
+    });
+
+    it('should render its own timestamp when MessageTimestamp is not overridden', () => {
+      const message = generateMessage();
+      const items = [
+        makeImageItem({ createdAt: new Date('2025-01-01T12:34:56.000Z'), message }),
+      ];
+
+      const { container } = renderGalleryUI(items);
+
+      expect(
+        container.querySelector('time.str-chat__gallery__timestamp'),
+      ).toHaveAttribute('datetime', '2025-01-01T12:34:56.000Z');
+    });
+
     it('should fall back to the item title and omit the timestamp when the item has no sender', () => {
       const items = [makeImageItem({ title: 'beach.png' })];
 
diff --git a/src/components/Message/MessageRepliesCountButton.tsx b/src/components/Message/MessageRepliesCountButton.tsx
index d9063580af..ff35c984ec 100644
--- a/src/components/Message/MessageRepliesCountButton.tsx
+++ b/src/components/Message/MessageRepliesCountButton.tsx
@@ -38,7 +38,7 @@ function UnMemoizedMessageRepliesCountButton(props: MessageRepliesCountButtonPro
     thread_participants: threadParticipantsFromProps = [],
   } = props;
   // reply counts also render outside a message, from props alone
-  const { message: contextMessage } = useContext(MessageContext) ?? {};
+  const { handleOpenThread, message: contextMessage } = useContext(MessageContext) ?? {};
   const channel = useChannel();
   const { openThread } = useWorkspaceNavigation();
   const replyMetadataSelector = useMemo(
@@ -75,9 +75,15 @@ function UnMemoizedMessageRepliesCountButton(props: MessageRepliesCountButtonPro
       }
 
       if (!contextMessage) return;
+      // The message's own handler honors a `Message.openThread` override before falling back to
+      // workspace navigation.
+      if (handleOpenThread) {
+        handleOpenThread(event);
+        return;
+      }
       void openThread({ channel, message: contextMessage });
     },
-    [channel, contextMessage, onClick, openThread],
+    [channel, contextMessage, handleOpenThread, onClick, openThread],
   );
 
   if (!replyCount) return null;
diff --git a/src/components/Message/MessageTimestamp.tsx b/src/components/Message/MessageTimestamp.tsx
index a91c3d7410..9b244e7d0e 100644
--- a/src/components/Message/MessageTimestamp.tsx
+++ b/src/components/Message/MessageTimestamp.tsx
@@ -1,6 +1,6 @@
 import { convertTimestampToDate } from 'stream-chat';
-import React from 'react';
-import { useMessageContext } from '../../context/MessageContext';
+import React, { useContext } from 'react';
+import { MessageContext } from '../../context/MessageContext';
 import { Timestamp as DefaultTimestamp } from './Timestamp';
 import { useComponentContext } from '../../context';
 
@@ -16,9 +16,11 @@ export type MessageTimestampProps = TimestampFormatterOptions & {
 
 const UnMemoizedMessageTimestamp = (props: MessageTimestampProps) => {
   const { message: propMessage, ...timestampProps } = props;
-  const { message: contextMessage } = useMessageContext();
+  // with a `message` prop it also renders outside a message (e.g. the gallery header)
+  const { message: contextMessage } = useContext(MessageContext) ?? {};
   const { Timestamp = DefaultTimestamp } = useComponentContext();
   const message = propMessage || contextMessage;
+  if (!message) return null;
   return (
     <Timestamp
       timestamp={convertTimestampToDate(message.created_at)}
diff --git a/src/components/Message/__tests__/MessageRepliesCountButton.test.tsx b/src/components/Message/__tests__/MessageRepliesCountButton.test.tsx
index c1cfee55e7..705a659be5 100644
--- a/src/components/Message/__tests__/MessageRepliesCountButton.test.tsx
+++ b/src/components/Message/__tests__/MessageRepliesCountButton.test.tsx
@@ -2,11 +2,18 @@ import React from 'react';
 import { cleanup, fireEvent, render } from '@testing-library/react';
 import type { Channel as ChannelType, StreamChat } from 'stream-chat';
 import { MessageRepliesCountButton } from '../MessageRepliesCountButton';
+import { Message } from '../Message';
 import { Channel } from '../../Channel';
 import { Chat } from '../../Chat';
-import { TranslationProvider } from '../../../context';
+import {
+  defaultWorkspaceNavigation,
+  TranslationProvider,
+  WithComponents,
+  WorkspaceNavigationProvider,
+} from '../../../context';
 import type { TranslationContextValue } from '../../../context';
 import {
+  generateMessage,
   initClientWithChannels,
   mockTranslationContextValue,
 } from '../../../mock-builders';
@@ -101,6 +108,66 @@ describe('MessageRepliesCountButton', () => {
     expect(queryByTestId('reply-icon')).not.toBeInTheDocument();
   });
 
+  describe('inside a Message, without an onClick prop', () => {
+    // A MessageUI that renders the button the way the default one does: without `onClick`.
+    const ReplyCountOnlyMessageUI = () => <MessageRepliesCountButton reply_count={2} />;
+
+    const renderInMessage = ({
+      openThread,
+      workspaceOpenThread = vi.fn(),
+    }: {
+      openThread?: (...args: unknown[]) => void;
+      workspaceOpenThread?: (...args: unknown[]) => void;
+    }) => {
+      const message = generateMessage({ reply_count: 2 });
+      const result = render(
+        <Chat client={client}>
+          <Channel channel={channel}>
+            <TranslationProvider value={mockTranslationContextValue({ t: i18nMock })}>
+              <WorkspaceNavigationProvider
+                value={{ ...defaultWorkspaceNavigation, openThread: workspaceOpenThread }}
+              >
+                <WithComponents overrides={{ MessageUI: ReplyCountOnlyMessageUI }}>
+                  <Message message={message} openThread={openThread} />
+                </WithComponents>
+              </WorkspaceNavigationProvider>
+            </TranslationProvider>
+          </Channel>
+        </Chat>,
+      );
+      return { message, ...result };
+    };
+
+    it("calls the Message's openThread override", () => {
+      const openThread = vi.fn();
+      const workspaceOpenThread = vi.fn();
+      const { getByTestId, message } = renderInMessage({
+        openThread,
+        workspaceOpenThread,
+      });
+
+      fireEvent.click(getByTestId('replies-count-button'));
+
+      expect(openThread).toHaveBeenCalledWith(
+        expect.objectContaining({ id: message.id }),
+        expect.anything(),
+      );
+      expect(workspaceOpenThread).not.toHaveBeenCalled();
+    });
+
+    it('opens the thread through workspace navigation without an override', () => {
+      const workspaceOpenThread = vi.fn();
+      const { getByTestId, message } = renderInMessage({ workspaceOpenThread });
+
+      fireEvent.click(getByTestId('replies-count-button'));
+
+      expect(workspaceOpenThread).toHaveBeenCalledWith({
+        channel,
+        message: expect.objectContaining({ id: message.id }),
+      });
+    });
+  });
+
   // MERGE-RECONCILE (test migration): the reply-count button no longer gates on the
   // 'send-reply' channel capability (permission gating was removed from this component in
   // the slot-layout refactor). The button now always renders enabled.
diff --git a/src/components/MessageComposer/hooks/__tests__/useIsCooldownActive.test.tsx b/src/components/MessageComposer/hooks/__tests__/useIsCooldownActive.test.tsx
new file mode 100644
index 0000000000..48503d313e
--- /dev/null
+++ b/src/components/MessageComposer/hooks/__tests__/useIsCooldownActive.test.tsx
@@ -0,0 +1,50 @@
+import React from 'react';
+import { act, renderHook, type RenderHookResult } from '@testing-library/react';
+import { fromPartial } from '@total-typescript/shoehorn';
+
+// Imported through the package entry: the hook is public API, named in the migration guide.
+import { useIsCooldownActive } from '../../../../index';
+
+import { Chat } from '../../../Chat';
+import { Channel } from '../../../Channel';
+import { initClientWithChannels } from '../../../../mock-builders';
+
+describe('useIsCooldownActive', () => {
+  const setup = async () => {
+    const {
+      channels: [channel],
+      client,
+    } = await initClientWithChannels();
+
+    const wrapper = ({ children }) => (
+      <Chat client={client}>
+        <Channel channel={channel}>{children}</Channel>
+      </Chat>
+    );
+
+    let result: RenderHookResult<boolean, unknown>;
+    await act(() => {
+      result = renderHook(() => useIsCooldownActive(), { wrapper });
+    });
+    return { channel, ...result };
+  };
+
+  it('is false when no cooldown is active', async () => {
+    const { result } = await setup();
+    expect(result.current).toBe(false);
+  });
+
+  it('follows the channel cooldown timer', async () => {
+    const { channel, result } = await setup();
+
+    await act(() => {
+      channel.cooldownTimer.state.next(fromPartial({ cooldownRemaining: 10 }));
+    });
+    expect(result.current).toBe(true);
+
+    await act(() => {
+      channel.cooldownTimer.state.next(fromPartial({ cooldownRemaining: 0 }));
+    });
+    expect(result.current).toBe(false);
+  });
+});
diff --git a/src/components/MessageComposer/hooks/index.ts b/src/components/MessageComposer/hooks/index.ts
index a387e28eb7..e4cd3d4629 100644
--- a/src/components/MessageComposer/hooks/index.ts
+++ b/src/components/MessageComposer/hooks/index.ts
@@ -2,6 +2,7 @@ export * from './useAttachmentManagerState';
 export * from './useAttachmentsForPreview';
 export * from './useCanCreatePoll';
 export * from './useCooldownRemaining';
+export * from './useIsCooldownActive';
 export * from './useMessageComposerBindings';
 export * from './useMessageComposerCommands';
 export * from './useMessageComposerController';
diff --git a/src/components/MessageList/MessageList.tsx b/src/components/MessageList/MessageList.tsx
index 242957bcfc..5c1f8c5356 100644
--- a/src/components/MessageList/MessageList.tsx
+++ b/src/components/MessageList/MessageList.tsx
@@ -36,7 +36,6 @@ import { useThreadContext } from '../Threads';
 import { useThreadHead } from './hooks/useThreadHead';
 
 import type {
-  LocalMessage,
   MessageFocusSignalState,
   MessagePaginatorState,
   TimestampNS,
@@ -57,7 +56,6 @@ import { useCanPaginateReplies } from './hooks/useCanPaginateReplies';
 type MessageListWithContextProps = MessageListProps;
 
 const messagePaginatorStateSelector = (state: MessagePaginatorState) => ({
-  // hasMore: state.hasMoreTail,
   hasMoreNewer: state.hasMoreHead,
   isLoading: state.isLoading,
   messages: state.items ?? [],
@@ -94,7 +92,6 @@ const MessageListWithContext = (props: MessageListWithContextProps) => {
     } = {},
     maxTimeBetweenGroupedMessages,
     noGroupByUser = false,
-    // messageLimit = DEFAULT_NEXT_CHANNEL_PAGE_SIZE,
     reactionDetailsSort,
     renderMessages = defaultRenderMessages,
     returnAllReadData = false,
@@ -107,10 +104,8 @@ const MessageListWithContext = (props: MessageListWithContextProps) => {
   } = props;
   const thread = useThreadContext();
   const isThreadList = !!thread;
-  const [suppressAutoscrollWhileLoadingOlder, setSuppressAutoscrollWhileLoadingOlder] =
-    React.useState(false);
-  const suppressAutoscroll =
-    suppressAutoscrollFromProps || suppressAutoscrollWhileLoadingOlder;
+  const [isLoadingOlder, setIsLoadingOlder] = React.useState(false);
+  const suppressAutoscroll = suppressAutoscrollFromProps || isLoadingOlder;
   const loadingOlderRef = React.useRef(false);
 
   const [listElement, setListElement] = React.useState<HTMLDivElement | null>(null);
@@ -238,12 +233,12 @@ const MessageListWithContext = (props: MessageListWithContextProps) => {
   const loadOlderMessages = React.useCallback(async () => {
     if (loadingOlderRef.current) return;
     loadingOlderRef.current = true;
-    setSuppressAutoscrollWhileLoadingOlder(true);
+    setIsLoadingOlder(true);
     try {
       await messagePaginator.toTail();
     } finally {
       loadingOlderRef.current = false;
-      setSuppressAutoscrollWhileLoadingOlder(false);
+      setIsLoadingOlder(false);
     }
   }, [messagePaginator]);
 
@@ -396,7 +391,7 @@ const MessageListWithContext = (props: MessageListWithContextProps) => {
                 {threadHead}
                 {isLoading && (
                   <div className='str-chat__list__loading' key='loading-indicator'>
-                    {props.loadingMore && <LoadingIndicator />}
+                    {(props.loadingMore ?? isLoadingOlder) && <LoadingIndicator />}
                   </div>
                 )}
                 <MessageListWrapper className='str-chat__ul'>
@@ -465,8 +460,6 @@ export type MessageListProps = Partial<Pick<MessageProps, PropsDrilledToMessage>
     noGroupByUser: boolean,
     maxTimeBetweenGroupedMessages?: number,
   ) => GroupStyle;
-  /** Whether the list has more items to load */
-  hasMore?: boolean;
   /**
    * Position to render HeaderComponent, as a timestamp in the same unit as `message.created_at` —
    * i.e. unix nanoseconds. Was milliseconds while `created_at` was a `Date`.
@@ -480,22 +473,13 @@ export type MessageListProps = Partial<Pick<MessageProps, PropsDrilledToMessage>
   hideNewMessageSeparator?: boolean;
   /** Overrides the default props passed to [InfiniteScrollPaginator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/InfiniteScrollPaginator/InfiniteScrollPaginator.tsx) */
   internalInfiniteScrollProps?: InternalPaginatorProps;
-  /** Function called when latest messages should be loaded, after the list has jumped at an earlier message set */
-  jumpToLatestMessage?: () => Promise<void>;
-  /** Whether or not the list is currently loading more items */
+  /**
+   * Whether to show the `LoadingIndicator` in the row above the messages while the message
+   * paginator is loading. Defaults to showing it while an older page loads.
+   */
   loadingMore?: boolean;
-  /** Whether or not the list is currently loading newer items */
-  loadingMoreNewer?: boolean;
-  /** Function called when more messages are to be loaded. */
-  // loadMore?: () => Promise<void>;
-  /** Function called when newer messages are to be loaded. */
-  // loadMoreNewer?: () => Promise<void>;
   /** Maximum time in milliseconds that should occur between messages to still consider them grouped together */
   maxTimeBetweenGroupedMessages?: number;
-  /** The limit to use when paginating messages */
-  messageLimit?: number;
-  /** The messages to render in the list; defaults to the active message-paginator items. */
-  messages?: LocalMessage[];
   /** If true, turns off message UI grouping by user */
   noGroupByUser?: boolean;
   /** Overrides the way MessageList renders messages */
diff --git a/src/components/MessageList/VirtualizedMessageList.tsx b/src/components/MessageList/VirtualizedMessageList.tsx
index 7f0c8c3886..84f77665b7 100644
--- a/src/components/MessageList/VirtualizedMessageList.tsx
+++ b/src/components/MessageList/VirtualizedMessageList.tsx
@@ -146,11 +146,6 @@ export type VirtuosoContext = Required<
 
 type VirtualizedMessageListWithContextProps = VirtualizedMessageListProps & {
   channel: Channel;
-  // hasMore: boolean;
-  // hasMoreNewer: boolean;
-  // jumpToLatestMessage: () => Promise<void>;
-  // loadingMore: boolean;
-  // loadingMoreNewer: boolean;
   read?: StreamChannelState['read'];
 };
 
@@ -218,23 +213,15 @@ const VirtualizedMessageListWithContext = (
     additionalMessageComposerProps,
     additionalVirtuosoProps = {},
     channel,
-    // channelUnreadUiState,
     closeReactionSelectorOnClick,
     customMessageRenderer,
     defaultItemHeight,
     formatDate,
     groupStyles,
     hideDeletedMessages = false,
-    // hasMoreNewer,
     hideNewMessageSeparator = false,
     maxTimeBetweenGroupedMessages,
-    // jumpToLatestMessage,
-    // loadingMore,
-    // loadMore,
-    // loadMoreNewer,
     overscan = 0,
-    // messageLimit = DEFAULT_NEXT_CHANNEL_PAGE_SIZE,
-    // messages,
     // TODO: refactor to scrollSeekPlaceHolderConfiguration and components.ScrollSeekPlaceholder, like the Virtuoso Component
     reactionDetailsSort,
     renderText,
@@ -489,8 +476,6 @@ const VirtualizedMessageListWithContext = (
     setNewMessagesNotification,
     // processedMessages were incorrectly rebuilt with a new object identity at some point, hence the .length usage
     // processedMessages.length,
-    // hasMoreNewer,
-    // jumpToLatestMessage,
   ]);
 
   useScrollToBottomOnNewMessage({
@@ -550,7 +535,6 @@ const VirtualizedMessageListWithContext = (
       // An empty thread is at both ends at once, so Virtuoso reports both on mount — see
       // `useCanPaginateReplies` for why that must not become a request.
       if (canPaginateReplies) messagePaginator.toHead();
-      // loadMoreNewer?.(messageLimit);
       setNewMessagesNotification?.(false);
     }
   };
@@ -733,28 +717,12 @@ export type VirtualizedMessageListProps = Partial<
     noGroupByUser: boolean,
     maxTimeBetweenGroupedMessages?: number,
   ) => GroupStyle;
-  // /** Whether or not the list has more items to load */
-  // hasMore?: boolean;
-  // /** Whether or not the list has newer items to load */
-  // hasMoreNewer?: boolean;
   /** Hides the `MessageDeleted` components from the list, defaults to `false` */
   hideDeletedMessages?: boolean;
   /** Hides the `DateSeparator` component when new messages are received in a channel that's watched but not active, defaults to false */
   hideNewMessageSeparator?: boolean;
-  // /** Whether or not the list is currently loading more items */
-  // loadingMore?: boolean;
-  // /** Whether or not the list is currently loading newer items */
-  // loadingMoreNewer?: boolean;
-  /** Function called when more messages are to be loaded. */
-  // loadMore?: () => Promise<void>;
-  /** Function called when new messages are to be loaded. */
-  // loadMoreNewer?: () => Promise<void>;
   /** Maximum time in milliseconds that should occur between messages to still consider them grouped together */
   maxTimeBetweenGroupedMessages?: number;
-  // /** The limit to use when paginating messages */
-  // messageLimit?: number;
-  /** Optional prop to override the messages available from the active message paginator. */
-  messages?: LocalMessage[];
   /**
    * @deprecated Use additionalVirtuosoProps.overscan instead. Will be removed with next major release - `v11.0.0`.
    * The amount of extra content the list should render in addition to what's necessary to fill in the viewport
@@ -818,8 +786,6 @@ export function VirtualizedMessageList(props: VirtualizedMessageListProps) {
 
   const { read } = useStateStore(channel?.state, channelReadSelector) ?? {};
 
-  const messages = props.messages; // || contextMessages;
-
   // See the note in `MessageList`: the panel and the notification area sit above the key, so a
   // notification keeps its element, its countdown and its box across a switch. Here it also puts
   // them above `VirtualizedMessageListWithContext`'s `if (!processedMessages) return null`, which
@@ -832,15 +798,6 @@ export function VirtualizedMessageList(props: VirtualizedMessageListProps) {
         // See the note in MessageList: this list's local state -- Virtuoso's scroll offset above all
         // -- is scoped to whatever it is showing, a thread's replies or a channel's messages.
         key={getMessageSourceKey({ channel, thread })}
-        // channelUnreadUiState={props.channelUnreadUiState ?? channelUnreadUiState}
-        // hasMore={!!hasMore}
-        // hasMoreNewer={!!hasMoreNewer}
-        // jumpToLatestMessage={jumpToLatestMessage}
-        // loadingMore={!!loadingMore}
-        // loadingMoreNewer={!!loadingMoreNewer}
-        // loadMore={loadMore}
-        // loadMoreNewer={loadMoreNewer}
-        messages={messages}
         read={read}
         {...props}
       />
diff --git a/src/components/MessageList/__tests__/MessageList.test.tsx b/src/components/MessageList/__tests__/MessageList.test.tsx
index 3949b4b774..acdc378a97 100644
--- a/src/components/MessageList/__tests__/MessageList.test.tsx
+++ b/src/components/MessageList/__tests__/MessageList.test.tsx
@@ -266,6 +266,87 @@ describe('MessageList', () => {
     // expect(results).toHaveNoViolations();
   });
 
+  describe('older-page loading indicator', () => {
+    // Scrolls the list to its top (jsdom has no layout, so `offsetParent` is stubbed) and holds
+    // `toTail` open, so the list stays in the "loading an older page" state.
+    const startLoadingOlder = async (msgListProps?: Partial<MessageListProps>) => {
+      const pageDeferred = createDeferred();
+      const toTail = vi
+        .spyOn(channel.messagePaginator, 'toTail')
+        .mockImplementation(async () => {
+          channel.messagePaginator.state.partialNext({ isLoading: true });
+          await pageDeferred.promise;
+          channel.messagePaginator.state.partialNext({ isLoading: false });
+        });
+      const { container } = renderComponent({
+        channelProps: { channel },
+        chatClient,
+        msgListProps: {
+          ...msgListProps,
+          internalInfiniteScrollProps: { loadNextDebounceMs: 0 },
+        },
+      });
+      const scroller = await screen.findByTestId('reverse-infinite-scroll');
+      Object.defineProperty(scroller, 'offsetParent', {
+        configurable: true,
+        get: () => document.body,
+      });
+      fireEvent.scroll(scroller);
+      await waitFor(() => expect(toTail).toHaveBeenCalled());
+      return { container, pageDeferred };
+    };
+
+    it('shows the loading indicator while an older page loads', async () => {
+      const { container, pageDeferred } = await startLoadingOlder();
+
+      await waitFor(() => {
+        expect(
+          container.querySelector(
+            '.str-chat__list__loading .str-chat__loading-indicator',
+          ),
+        ).toBeInTheDocument();
+      });
+
+      await act(() => {
+        pageDeferred.resolve();
+      });
+      await waitFor(() => {
+        expect(
+          container.querySelector('.str-chat__list__loading'),
+        ).not.toBeInTheDocument();
+      });
+    });
+
+    it('hides the loading indicator when loadingMore is false', async () => {
+      const { container, pageDeferred } = await startLoadingOlder({ loadingMore: false });
+
+      await waitFor(() => {
+        expect(container.querySelector('.str-chat__list__loading')).toBeInTheDocument();
+      });
+      expect(
+        container.querySelector('.str-chat__list__loading .str-chat__loading-indicator'),
+      ).not.toBeInTheDocument();
+
+      await act(() => {
+        pageDeferred.resolve();
+      });
+    });
+
+    it('does not show the loading indicator while a newer page loads', async () => {
+      const { container } = renderComponent({ channelProps: { channel }, chatClient });
+      await screen.findByTestId('reverse-infinite-scroll');
+
+      await act(() => {
+        channel.messagePaginator.state.partialNext({ isLoading: true });
+      });
+
+      expect(container.querySelector('.str-chat__list__loading')).toBeInTheDocument();
+      expect(
+        container.querySelector('.str-chat__list__loading .str-chat__loading-indicator'),
+      ).not.toBeInTheDocument();
+    });
+  });
+
   it('should render a ThreadHead override above the replies', async () => {
     const CustomThreadHead = (props: { message: Pick<typeof message1, 'text'> }) => (
       <div>{props.message.text}</div>
@@ -607,7 +688,7 @@ describe('MessageList', () => {
           <Chat client={client}>
             <Channel channel={channel}>
               <MarkReadButton />
-              <MessageList messages={messages} />
+              <MessageList />
             </Channel>
           </Chat>,
         );
@@ -1689,7 +1770,7 @@ describe('MessageList', () => {
                     hasMoreNewer={canLoadNewer}
                     messages={renderedMessages}
                   >
-                    <MessageList messages={renderedMessages} />
+                    <MessageList />
                   </SyncPaginator>
                 </Channel>
               </Chat>
diff --git a/src/components/MessageList/renderMessages.tsx b/src/components/MessageList/renderMessages.tsx
index 65d246114d..5438e0a52a 100644
--- a/src/components/MessageList/renderMessages.tsx
+++ b/src/components/MessageList/renderMessages.tsx
@@ -14,7 +14,6 @@ import type {
   UserResponse,
 } from 'stream-chat';
 import type { ComponentContextValue, CustomClasses } from '../../context';
-// import type { ChannelUnreadUiState } from '../../types';
 
 export interface RenderMessagesOptions {
   channel: Channel;
diff --git a/src/context/ChannelListContext.tsx b/src/context/ChannelListContext.tsx
index 88e9b94abc..46898a9106 100644
--- a/src/context/ChannelListContext.tsx
+++ b/src/context/ChannelListContext.tsx
@@ -7,7 +7,7 @@ export type ChannelListContextValue = {
   /**
    * The primary channel paginator held by the `ChannelManager` on `ChatContext`.
    * Read the loaded channels reactively with `useStateStore(paginator.state, …)`, load the next
-   * page with `paginator.next()`, and mutate the loaded list (e.g. prepend a just-opened channel)
+   * page with `paginator.toTail()`, and mutate the loaded list (e.g. prepend a just-opened channel)
    * via `paginator.setItems({ valueOrFactory })`. Undefined when rendered outside a channel list.
    */
   paginator?: ChannelPaginator;
diff --git a/src/context/ChatContext.tsx b/src/context/ChatContext.tsx
index 0a997f1770..90ad1e08b0 100644
--- a/src/context/ChatContext.tsx
+++ b/src/context/ChatContext.tsx
@@ -12,7 +12,6 @@ import { requireContext } from './requireContext';
 
 type CSSClasses =
   | 'chat'
-  | 'chatContainer'
   | 'channel'
   | 'channelList'
   | 'message'
diff --git a/src/context/ComponentContext.tsx b/src/context/ComponentContext.tsx
index 4eda3c6699..ac7525fbd1 100644
--- a/src/context/ComponentContext.tsx
+++ b/src/context/ComponentContext.tsx
@@ -20,7 +20,6 @@ import {
   type GalleryProps,
   type GiphyPreviewMessageProps,
   type ImagePlaceholderProps,
-  type LoadingErrorIndicatorProps,
   type LoadingIndicatorProps,
   type MessageBouncePromptProps,
   type MessageComposerProps,
@@ -177,8 +176,6 @@ export type ComponentContextValue = {
   MessageComposerUI?: React.ComponentType<MessageComposerProps>;
   /** Custom component to render link previews in message composer **/
   LinkPreviewList?: React.ComponentType;
-  /** Custom UI component to be shown if the channel query fails, defaults to and accepts same props as: [LoadingErrorIndicator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Loading/LoadingErrorIndicator.tsx) */
-  LoadingErrorIndicator?: React.ComponentType<LoadingErrorIndicatorProps>;
   /** Custom UI component to render while the `MessageList` is loading new messages, defaults to and accepts same props as: [LoadingIndicator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Loading/LoadingIndicator.tsx) */
   LoadingIndicator?: React.ComponentType<LoadingIndicatorProps>;
   /** Custom UI component for determinate progress (0–100), defaults to and accepts same props as: [ProgressIndicator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Loading/progress-indicators.tsx) */
diff --git a/src/context/WorkspaceNavigationContext.tsx b/src/context/WorkspaceNavigationContext.tsx
index cf669d4c0a..1cce89fff4 100644
--- a/src/context/WorkspaceNavigationContext.tsx
+++ b/src/context/WorkspaceNavigationContext.tsx
@@ -158,8 +158,41 @@ export const defaultWorkspaceNavigation: WorkspaceNavigation = {
   openThreads: NOOP_OPEN_THREADS,
 };
 
+type WorkspaceNavigationAction =
+  | 'closeChannel'
+  | 'closeThread'
+  | 'goBack'
+  | 'openChannel'
+  | 'openThread';
+
+const warnedUnprovidedActions = new Set<WorkspaceNavigationAction>();
+
+const warnUnprovided = (action: WorkspaceNavigationAction) => {
+  if (warnedUnprovidedActions.has(action)) return;
+  warnedUnprovidedActions.add(action);
+  console.warn(
+    `stream-chat-react: WorkspaceNavigation.${action}() did nothing because no workspace navigation is provided. ` +
+      'Render the component inside ChatView (stream-chat-react/slot-layout), or provide your own navigation with WorkspaceNavigationProvider.',
+  );
+};
+
+/**
+ * What `useWorkspaceNavigation()` returns with no provider: {@link defaultWorkspaceNavigation}, but
+ * its operations warn (once each) that nothing happened, since a click that silently does nothing
+ * is hard to trace back to a missing `ChatView`. `defaultWorkspaceNavigation` itself stays silent,
+ * as it is the base an integrator spreads into their own provider value.
+ */
+const unprovidedWorkspaceNavigation: WorkspaceNavigation = {
+  ...defaultWorkspaceNavigation,
+  closeChannel: () => warnUnprovided('closeChannel'),
+  closeThread: () => warnUnprovided('closeThread'),
+  goBack: () => warnUnprovided('goBack'),
+  openChannel: () => warnUnprovided('openChannel'),
+  openThread: () => warnUnprovided('openThread'),
+};
+
 const WorkspaceNavigationContext = createContext<WorkspaceNavigation>(
-  defaultWorkspaceNavigation,
+  unprovidedWorkspaceNavigation,
 );
 
 export const WorkspaceNavigationProvider = ({
@@ -174,6 +207,7 @@ export const WorkspaceNavigationProvider = ({
 /**
  * Access the workspace navigation abstraction. Returns the inert no-op default outside a
  * `slot-layout` provider, so callers can navigate unconditionally without guarding for a provider.
+ * Without a provider, each operation logs a one-time console warning when called.
  */
 export const useWorkspaceNavigation = (): WorkspaceNavigation =>
   useContext(WorkspaceNavigationContext);
diff --git a/src/context/__tests__/WorkspaceNavigationContext.test.tsx b/src/context/__tests__/WorkspaceNavigationContext.test.tsx
index efd94396d7..a6d05a6731 100644
--- a/src/context/__tests__/WorkspaceNavigationContext.test.tsx
+++ b/src/context/__tests__/WorkspaceNavigationContext.test.tsx
@@ -35,6 +35,60 @@ describe('WorkspaceNavigationContext', () => {
       ).not.toThrow();
       expect(() => result.current.closeThread('thread-1')).not.toThrow();
     });
+
+    it('warns once per operation that nothing happened', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const { result } = renderHook(() => useWorkspaceNavigation());
+
+      result.current.closeChannel('messaging:x');
+      result.current.closeChannel('messaging:y');
+      result.current.goBack('messaging:x');
+
+      const closeChannelWarnings = warn.mock.calls.filter(([message]) =>
+        String(message).includes('WorkspaceNavigation.closeChannel()'),
+      );
+      expect(closeChannelWarnings).toHaveLength(1);
+      expect(String(closeChannelWarnings[0][0])).toContain('ChatView');
+      expect(
+        warn.mock.calls.some(([message]) =>
+          String(message).includes('WorkspaceNavigation.goBack()'),
+        ),
+      ).toBe(true);
+
+      warn.mockRestore();
+    });
+
+    it('does not warn from reads or from the exported default', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const { result } = renderHook(() => useWorkspaceNavigation());
+
+      result.current.isChannelActive('messaging:x');
+      result.current.canGoBack('messaging:x');
+      defaultWorkspaceNavigation.openChannel(
+        fromPartial<Channel>({ cid: 'messaging:x' }),
+      );
+      defaultWorkspaceNavigation.closeThread('thread-1');
+
+      expect(warn).not.toHaveBeenCalled();
+      warn.mockRestore();
+    });
+  });
+
+  describe('with a provider', () => {
+    it('does not warn when the provider leaves an operation at the default', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <WorkspaceNavigationProvider value={defaultWorkspaceNavigation}>
+          {children}
+        </WorkspaceNavigationProvider>
+      );
+      const { result } = renderHook(() => useWorkspaceNavigation(), { wrapper });
+
+      result.current.openThread(fromPartial<Thread>({ id: 'thread-1' }));
+
+      expect(warn).not.toHaveBeenCalled();
+      warn.mockRestore();
+    });
   });
 
   describe('with a provider', () => {
diff --git a/src/hooks/__tests__/useMessagePaginator.test.tsx b/src/hooks/__tests__/useMessagePaginator.test.tsx
new file mode 100644
index 0000000000..f86c8fea43
--- /dev/null
+++ b/src/hooks/__tests__/useMessagePaginator.test.tsx
@@ -0,0 +1,53 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react';
+import { fromPartial } from '@total-typescript/shoehorn';
+import type { Thread } from 'stream-chat';
+
+// Imported through the package entry: the hook is public API.
+import { useMessagePaginator } from '../../index';
+
+import { Chat } from '../../components/Chat';
+import { Channel } from '../../components/Channel';
+import { ThreadProvider } from '../../components/Threads';
+import { initClientWithChannels } from '../../mock-builders';
+
+describe('useMessagePaginator', () => {
+  it("returns the channel's paginator inside Channel", async () => {
+    const {
+      channels: [channel],
+      client,
+    } = await initClientWithChannels();
+
+    const { result } = renderHook(() => useMessagePaginator(), {
+      wrapper: ({ children }) => (
+        <Chat client={client}>
+          <Channel channel={channel}>{children}</Channel>
+        </Chat>
+      ),
+    });
+
+    expect(result.current).toBe(channel.messagePaginator);
+  });
+
+  it("prefers the thread's paginator inside a thread", async () => {
+    const {
+      channels: [channel],
+      client,
+    } = await initClientWithChannels();
+    const thread = fromPartial<Thread>({
+      messagePaginator: fromPartial({}),
+    });
+
+    const { result } = renderHook(() => useMessagePaginator(), {
+      wrapper: ({ children }) => (
+        <Chat client={client}>
+          <Channel channel={channel}>
+            <ThreadProvider thread={thread}>{children}</ThreadProvider>
+          </Channel>
+        </Chat>
+      ),
+    });
+
+    expect(result.current).toBe(thread.messagePaginator);
+  });
+});
diff --git a/src/index.ts b/src/index.ts
index b86ce062dc..01b498b37b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,6 @@
 export * from './components';
 export * from './context';
+export { useMessagePaginator } from './hooks/useMessagePaginator';
 export * from './i18n';
 export * from './store';
 export * from './types';
diff --git a/src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts b/src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts
index e7744463a3..faa4c9376b 100644
--- a/src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts
+++ b/src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts
@@ -1,6 +1,7 @@
 import {
   type Attachment,
   convertTimestampToDate,
+  formatMessage,
   isImageAttachment,
   isVideoAttachment,
   type LocalMessage,
@@ -47,6 +48,8 @@ export const toChannelMediaItems = (
   const items: ChannelMediaItem[] = [];
 
   messages.forEach((message) => {
+    // the gallery header hands it to a `MessageTimestamp` override, which takes a `LocalMessage`
+    let localMessage: LocalMessage | undefined;
     message.attachments?.forEach((attachment, index) => {
       const type = getMediaAttachmentType(attachment);
       if (!type) return;
@@ -70,6 +73,7 @@ export const toChannelMediaItems = (
           ...descriptor,
           // the gallery header reads sender and timestamp off the item
           createdAt: convertTimestampToDate(message.created_at),
+          message: (localMessage ??= formatMessage(message)),
           user: message.user ?? undefined,
         },
         id: `${message.id}-${index}`,
diff --git a/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx b/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx
index 31736754e4..1feb4cbd70 100644
--- a/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx
+++ b/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx
@@ -16,8 +16,8 @@ import {
   useComponentContextIcons,
   useModalContext,
   useTranslationContext,
+  useWorkspaceNavigation,
 } from '../../../../context';
-import { useChatViewNavigation } from '../../../SlotLayout';
 import { useStableCallback } from '../../../../utils';
 import { useStateStore } from '../../../../store';
 import { Alert } from '../../../../components/Dialog';
@@ -219,7 +219,7 @@ export const useBaseChannelMemberActionSetFilter = (
 
 const SendDirectMessageAction = () => {
   const { channelManager, client } = useChatContext();
-  const { open } = useChatViewNavigation();
+  const { openChannel } = useWorkspaceNavigation();
   const { close } = useModalContext();
   const { channel } = useChannelDetailContext();
   const { addNotification } = useNotificationApi();
@@ -240,13 +240,10 @@ const SendDirectMessageAction = () => {
       });
       // the stored instance, if another one took the DM's cid while the watch was in flight
       const dm = await directMessageChannel.ensureWatched();
-      // Selection is one navigation model: open the DM into a layout slot, then route it into
+      // Selection is one navigation model: open the DM in the workspace (a layout slot inside
+      // `ChatView`, or whatever a custom `WorkspaceNavigationProvider` does), then route it into
       // the channel list(s) that should own it so it appears without a full re-query.
-      open({
-        key: dm.cid ?? undefined,
-        kind: 'channel',
-        source: dm,
-      });
+      openChannel(dm);
       channelManager.ingestChannel(dm);
       close();
     } catch (error) {
@@ -271,7 +268,7 @@ const SendDirectMessageAction = () => {
     close,
     channelManager,
     isSending,
-    open,
+    openChannel,
     t,
     targetUserId,
   ]);
diff --git a/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/__tests__/SendDirectMessageAction.test.tsx b/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/__tests__/SendDirectMessageAction.test.tsx
index 21eb56d5e8..39f0330412 100644
--- a/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/__tests__/SendDirectMessageAction.test.tsx
+++ b/src/plugins/ChannelDetail/Views/ChannelMemberDetailView/__tests__/SendDirectMessageAction.test.tsx
@@ -9,6 +9,7 @@ import {
   useComponentContextIcons,
   useModalContext,
   useTranslationContext,
+  useWorkspaceNavigation,
 } from '../../../../../context';
 import * as DEFAULT_ICONS from '../../../../../components/Icons/icons';
 import { ChannelDetailProvider } from '../../../ChannelDetailContext';
@@ -20,10 +21,7 @@ import { mockT } from '../../../../../mock-builders/translator';
 
 vi.mock('../../../../../context');
 
-const mockOpen = vi.fn();
-vi.mock('../../../../SlotLayout', () => ({
-  useChatViewNavigation: () => ({ open: mockOpen }),
-}));
+const mockOpenChannel = vi.fn();
 
 vi.mock('../../../../../components/Notifications', () => ({
   useNotificationApi: () => ({ addNotification: vi.fn() }),
@@ -65,6 +63,11 @@ describe('SendDirectMessage action', () => {
     vi.mocked(useComponentContext).mockReturnValue(
       {} as ReturnType<typeof useComponentContext>,
     );
+    // Workspace navigation, not ChatView's slot API, so a custom WorkspaceNavigationProvider
+    // outside ChatView receives the direct message too.
+    vi.mocked(useWorkspaceNavigation).mockReturnValue(
+      fromPartial({ openChannel: mockOpenChannel }),
+    );
   });
 
   it('opens and lists the direct message once it is watched', async () => {
@@ -78,9 +81,7 @@ describe('SendDirectMessage action', () => {
       await Promise.resolve();
     });
 
-    expect(mockOpen).toHaveBeenCalledWith(
-      expect.objectContaining({ key: 'messaging:dm', source: created }),
-    );
+    expect(mockOpenChannel).toHaveBeenCalledWith(created);
     expect(ingestChannel).toHaveBeenCalledWith(created);
   });
 
@@ -97,9 +98,7 @@ describe('SendDirectMessage action', () => {
       await Promise.resolve();
     });
 
-    expect(mockOpen).toHaveBeenCalledWith(
-      expect.objectContaining({ key: 'messaging:dm', source: stored }),
-    );
+    expect(mockOpenChannel).toHaveBeenCalledWith(stored);
     expect(ingestChannel).toHaveBeenCalledWith(stored);
   });
 });
diff --git a/src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx b/src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx
index 5c1f4e6e92..bb81f5d5c8 100644
--- a/src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx
+++ b/src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx
@@ -5,8 +5,8 @@ import {
   useComponentContext,
   useModalContext,
   useTranslationContext,
+  useWorkspaceNavigation,
 } from '../../../../context';
-import { useChatViewNavigation } from '../../../SlotLayout';
 import { getDateString } from '../../../../i18n/utils';
 import { Avatar as DefaultAvatar } from '../../../../components/Avatar';
 import { extractDisplayInfo as defaultExtractDisplayInfo } from '../../../../components/Avatar/utils';
@@ -140,7 +140,7 @@ export type PinnedMessagesViewProps = SectionNavigatorSectionContentProps & {
 export const PinnedMessagesView: React.ComponentType<PinnedMessagesViewProps> = ({
   searchSource,
 }) => {
-  const { open } = useChatViewNavigation();
+  const { openChannel } = useWorkspaceNavigation();
   const { t } = useTranslationContext();
   const { close } = useModalContext();
   const { channel } = useChannelDetailContext();
@@ -154,14 +154,14 @@ export const PinnedMessagesView: React.ComponentType<PinnedMessagesViewProps> =
 
   const handleSelectMessage = useCallback(
     (message: PinnedMessage) => {
-      // Selection is one navigation model: open the channel into a layout slot.
-      open({ key: channel.cid ?? undefined, kind: 'channel', source: channel });
+      // Selection is one navigation model: open the channel in the workspace.
+      openChannel(channel);
       // MERGE-RECONCILE: the deleted ChannelActionContext.jumpToMessage was replaced by the
       // channel's messagePaginator (PR #2909 / stream-chat message-paginator API).
       void channel.messagePaginator.jumpToMessage(message.id);
       close();
     },
-    [channel, close, open],
+    [channel, close, openChannel],
   );
 
   const renderItem = useCallback(
diff --git a/src/plugins/ChannelDetail/Views/PinnedMessagesView/__tests__/PinnedMessagesView.test.tsx b/src/plugins/ChannelDetail/Views/PinnedMessagesView/__tests__/PinnedMessagesView.test.tsx
index d713dd12da..131bd3609c 100644
--- a/src/plugins/ChannelDetail/Views/PinnedMessagesView/__tests__/PinnedMessagesView.test.tsx
+++ b/src/plugins/ChannelDetail/Views/PinnedMessagesView/__tests__/PinnedMessagesView.test.tsx
@@ -19,6 +19,7 @@ import {
   useComponentContextIcons,
   useModalContext,
   useTranslationContext,
+  useWorkspaceNavigation,
 } from '../../../../../context';
 import * as DEFAULT_ICONS from '../../../../../components/Icons/icons';
 import { mockT } from '../../../../../mock-builders/translator';
@@ -253,9 +254,33 @@ describe('PinnedMessagesView', () => {
       close: vi.fn(),
     } as ReturnType<typeof useModalContext>);
 
+    vi.mocked(useWorkspaceNavigation).mockReturnValue(
+      fromPartial({ openChannel: vi.fn() }),
+    );
+
     mockSearchSourceState();
   });
 
+  it('opens the channel through workspace navigation and jumps to the selected message', () => {
+    // Workspace navigation, not ChatView's slot API, so a custom WorkspaceNavigationProvider
+    // outside ChatView receives the selection too.
+    const openChannel = vi.fn();
+    const close = vi.fn();
+    vi.mocked(useWorkspaceNavigation).mockReturnValue(fromPartial({ openChannel }));
+    vi.mocked(useModalContext).mockReturnValue({
+      close,
+    } as unknown as ReturnType<typeof useModalContext>);
+    mockSearchSourceState({ messages: pinnedMessages });
+    const channel = createChannel();
+
+    renderWithChannel(<PinnedMessagesView layout='tabs' />, channel);
+    fireEvent.click(screen.getByText('Release timeline: Code freeze March 18'));
+
+    expect(openChannel).toHaveBeenCalledWith(channel);
+    expect(channel.messagePaginator.jumpToMessage).toHaveBeenCalledWith('message-1');
+    expect(close).toHaveBeenCalled();
+  });
+
   it('configures MessageSearchSource for pinned messages in the current channel', () => {
     renderWithChannel(<PinnedMessagesView layout='tabs' />);
 
diff --git a/src/types/index.ts b/src/types/index.ts
index b4b90d1229..a476dd8cb6 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -1,2 +1 @@
-// export type { ChannelUnreadUiState } from './types';
 export type * from './defaultDataInterfaces';
diff --git a/src/types/types.ts b/src/types/types.ts
index cf4589d438..d55a29a770 100644
--- a/src/types/types.ts
+++ b/src/types/types.ts
@@ -31,8 +31,6 @@ export interface IconProps {
 
 export type Dimensions = { height?: string; width?: string };
 
-// export type ChannelUnreadUiState = Omit<ValuesType<StreamChannelState['read']>, 'user'>;
-
 export type Readable<T> = {
   [key in keyof T]: T[key];
 } & {};

From e8dde4b0fd2926f02b891d7780dbec49f04f971a Mon Sep 17 00:00:00 2001
From: Oliver Lazoroski <oliver.lazoroski@gmail.com>
Date: Sat, 17 Oct 2026 12:03:41 +0200
Subject: [PATCH 2/5] fix(ChannelList): apply the theme scope only outside
 ChatView, plus the review fixes

A nested `.str-chat` on ChannelNavigation reset the token overrides an app
sets on the ChatView root and matched app CSS written for `.str-chat` roots
(the tutorial's channel list grew to half the row). ChatView now provides an
internal theme-scope context; ChannelNavigation applies `str-chat <theme>`
only without one, and a bare ChannelList brings a `display: contents` scope.

- MessageList raises the older-page indicator only when a tailward page can load
- MessageTimestamp throws again without a `message` prop or a MessageProvider
---
 src/components/ChannelList/ChannelList.tsx    | 39 +++++++++-------
 .../ChannelList/ChannelNavigation.tsx         | 29 +++++++-----
 .../__tests__/ChannelList.test.tsx            | 29 ++++++++++++
 .../__tests__/ChannelNavigation.test.tsx      | 20 +++++++++
 src/components/Message/MessageTimestamp.tsx   | 11 +++--
 .../__tests__/MessageTimestamp.test.tsx       | 27 ++++++++++++
 src/components/MessageList/MessageList.tsx    | 11 ++++-
 .../__tests__/MessageList.test.tsx            | 32 ++++++++++++++
 src/context/ThemeScopeContext.tsx             | 44 +++++++++++++++++++
 src/plugins/SlotLayout/ChatView.tsx           |  9 ++--
 .../SlotLayout/__tests__/ChatView.test.tsx    | 35 +++++++++++++++
 src/styling/base.scss                         |  6 +++
 12 files changed, 257 insertions(+), 35 deletions(-)
 create mode 100644 src/context/ThemeScopeContext.tsx

diff --git a/src/components/ChannelList/ChannelList.tsx b/src/components/ChannelList/ChannelList.tsx
index d6b802c93c..f3c5fa95d8 100644
--- a/src/components/ChannelList/ChannelList.tsx
+++ b/src/components/ChannelList/ChannelList.tsx
@@ -9,6 +9,7 @@ import { LoadingChannels, LoadingIndicator } from '../Loading';
 import { useChatContext } from '../../context/ChatContext';
 import { useComponentContext } from '../../context/ComponentContext';
 import { useTranslationContext } from '../../context/TranslationContext';
+import { ThemeScope } from '../../context/ThemeScopeContext';
 import { useChannelListKeyboardNavigation } from './hooks/useChannelListKeyboardNavigation';
 import { useStateStore } from '../../store';
 
@@ -82,24 +83,28 @@ export const ChannelList = ({
     });
   }, [client, lastQueryError]);
 
+  // Rendered on its own (no `ChannelNavigation` or `ChatView` above it), the list brings the theme
+  // scope with it.
   return (
-    <InfiniteScrollWithComponents<Channel>
-      aria-label={t('channelList.channelList.ariaLabel', 'Channel list')}
-      contentProps={{ role: 'presentation' }}
-      EmptyListIndicator={EmptyListIndicator}
-      EndReachedIndicator={EndReachedIndicator}
-      FirstPageLoadingIndicator={FirstPageLoadingIndicator}
-      ListItem={ListItem as ComponentType<{ item: Channel }>}
-      LoadingNextPageIndicator={LoadingNextPageIndicator}
-      loadNextDebounceMs={loadMoreDebounceMs}
-      loadNextOnScrollToBottom={paginator.toTail}
-      onClickCapture={onClickCapture}
-      onKeyDown={onKeyDown}
-      paginator={paginator}
-      ref={listboxRef}
-      role='listbox'
-      threshold={loadMoreThresholdPx}
-    />
+    <ThemeScope>
+      <InfiniteScrollWithComponents<Channel>
+        aria-label={t('channelList.channelList.ariaLabel', 'Channel list')}
+        contentProps={{ role: 'presentation' }}
+        EmptyListIndicator={EmptyListIndicator}
+        EndReachedIndicator={EndReachedIndicator}
+        FirstPageLoadingIndicator={FirstPageLoadingIndicator}
+        ListItem={ListItem as ComponentType<{ item: Channel }>}
+        LoadingNextPageIndicator={LoadingNextPageIndicator}
+        loadNextDebounceMs={loadMoreDebounceMs}
+        loadNextOnScrollToBottom={paginator.toTail}
+        onClickCapture={onClickCapture}
+        onKeyDown={onKeyDown}
+        paginator={paginator}
+        ref={listboxRef}
+        role='listbox'
+        threshold={loadMoreThresholdPx}
+      />
+    </ThemeScope>
   );
 };
 
diff --git a/src/components/ChannelList/ChannelNavigation.tsx b/src/components/ChannelList/ChannelNavigation.tsx
index d05d94b0af..565ea8828f 100644
--- a/src/components/ChannelList/ChannelNavigation.tsx
+++ b/src/components/ChannelList/ChannelNavigation.tsx
@@ -7,6 +7,11 @@ import { ChannelLists } from './ChannelLists';
 import { NotificationList as DefaultNotificationList } from '../Notifications';
 import { Search as DefaultSearch } from '../Search';
 import { useChatContext, useComponentContext } from '../../context';
+import {
+  ThemeScopeProvider,
+  useIsInThemeScope,
+  useThemeScopeClassName,
+} from '../../context/ThemeScopeContext';
 import { useImageFlagEmojisOnWindowsClass } from '../Channel/hooks/useChannelContainerClasses';
 import { useStateStore } from '../../store';
 
@@ -21,9 +26,10 @@ const searchControllerStateSelector = (state: SearchControllerState) => ({
  * search is inactive. Mapped to the channel-navigation slot; `Search` is customizable
  * via the `ComponentContext` `Search` slot.
  *
- * Its root carries the `str-chat` theme scope itself (like `Channel`), so the design tokens apply
- * when it is rendered outside `ChatView`. `customClasses.chat` / `customClasses.channelList`
- * replace the `str-chat` / `str-chat__channel-list` classes.
+ * Outside `ChatView` its root carries the `str-chat <theme>` scope itself, so the design tokens
+ * apply; inside one it inherits `ChatView`'s instead of resetting them with a nested scope.
+ * `customClasses.chat` / `customClasses.channelList` replace the `str-chat` /
+ * `str-chat__channel-list` classes.
  */
 export const ChannelNavigation = () => {
   const {
@@ -31,7 +37,9 @@ export const ChannelNavigation = () => {
     NotificationList = DefaultNotificationList,
     Search = DefaultSearch,
   } = useComponentContext();
-  const { customClasses, searchController, theme } = useChatContext();
+  const { customClasses, searchController } = useChatContext();
+  const isInThemeScope = useIsInThemeScope();
+  const themeScopeClassName = useThemeScopeClassName();
   const windowsEmojiClass = useImageFlagEmojisOnWindowsClass();
   const { isActive } = useStateStore(
     searchController.state,
@@ -41,16 +49,17 @@ export const ChannelNavigation = () => {
   return (
     <div
       className={clsx(
-        customClasses?.chat ?? 'str-chat',
-        theme,
+        !isInThemeScope && themeScopeClassName,
         customClasses?.channelList ?? 'str-chat__channel-list',
         windowsEmojiClass,
       )}
     >
-      <ChannelListHeader />
-      <Search />
-      {!isActive && <ChannelLists />}
-      <NotificationList panel='channel-list' />
+      <ThemeScopeProvider>
+        <ChannelListHeader />
+        <Search />
+        {!isActive && <ChannelLists />}
+        <NotificationList panel='channel-list' />
+      </ThemeScopeProvider>
     </div>
   );
 };
diff --git a/src/components/ChannelList/__tests__/ChannelList.test.tsx b/src/components/ChannelList/__tests__/ChannelList.test.tsx
index 10e0f22071..f55e937141 100644
--- a/src/components/ChannelList/__tests__/ChannelList.test.tsx
+++ b/src/components/ChannelList/__tests__/ChannelList.test.tsx
@@ -6,6 +6,7 @@ import { ChannelPaginator } from 'stream-chat';
 
 import { Chat } from '../../Chat';
 import { ChannelList } from '../ChannelList';
+import { ThemeScopeProvider } from '../../../context/ThemeScopeContext';
 import { getTestClientWithUser } from '../../../mock-builders';
 
 const setupClient = async () => {
@@ -28,6 +29,34 @@ const renderList = (client: StreamChat, paginator: ChannelPaginator) => {
 describe('ChannelList', () => {
   afterEach(cleanup);
 
+  it('brings a layout-neutral theme scope when rendered on its own', async () => {
+    const { client } = await setupClient();
+    const paginator = new ChannelPaginator({ client, id: 'channels:a' });
+    paginator.setItems({ isLastPage: true, valueOrFactory: [] });
+
+    const { container } = renderList(client, paginator);
+
+    const scope = container.firstElementChild;
+    expect(scope).toHaveClass('str-chat', 'messaging', 'light', 'str-chat__theme-scope');
+  });
+
+  it('adds no theme scope inside an existing one', async () => {
+    const { client } = await setupClient();
+    const paginator = new ChannelPaginator({ client, id: 'channels:a' });
+    paginator.setItems({ isLastPage: true, valueOrFactory: [] });
+    client.channelManager.insertPaginator({ paginator });
+
+    const { container } = render(
+      <Chat client={client}>
+        <ThemeScopeProvider>
+          <ChannelList paginator={paginator} />
+        </ThemeScopeProvider>
+      </Chat>,
+    );
+
+    expect(container.querySelector('.str-chat')).not.toBeInTheDocument();
+  });
+
   it('queries the first page of a list that has never been queried', async () => {
     const { client, queryChannels } = await setupClient();
     const paginator = new ChannelPaginator({ client, id: 'channels:a' });
diff --git a/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx b/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
index db850b778c..36ea46f09c 100644
--- a/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
+++ b/src/components/ChannelList/__tests__/ChannelNavigation.test.tsx
@@ -6,6 +6,7 @@ import type { StreamChat } from 'stream-chat';
 import { Chat } from '../../Chat';
 import type { ChatProps } from '../../Chat';
 import { ChannelNavigation } from '../ChannelNavigation';
+import { ThemeScopeProvider } from '../../../context/ThemeScopeContext';
 import { getTestClientWithUser } from '../../../mock-builders';
 import { axe } from '../../../../axe-helper';
 
@@ -57,6 +58,25 @@ describe('ChannelNavigation', () => {
     expect(root).not.toHaveClass('str-chat__channel-list');
   });
 
+  it('inherits an enclosing theme scope (e.g. ChatView) instead of nesting one', async () => {
+    // `.str-chat` declares the whole token set: a nested one would reset tokens an app overrides
+    // on the ChatView root, and pick up app CSS written for `.str-chat` roots.
+    const client = await setupClient();
+
+    const { container } = render(
+      <Chat client={client} customClasses={{ channelList: 'custom-channel-list' }}>
+        <ThemeScopeProvider>
+          <ChannelNavigation />
+        </ThemeScopeProvider>
+      </Chat>,
+    );
+
+    const root = container.firstElementChild;
+    expect(root).toHaveClass('custom-channel-list');
+    expect(root).not.toHaveClass('str-chat');
+    expect(container.querySelector('.str-chat')).not.toBeInTheDocument();
+  });
+
   it('has no axe violations', async () => {
     const client = await setupClient();
 
diff --git a/src/components/Message/MessageTimestamp.tsx b/src/components/Message/MessageTimestamp.tsx
index 9b244e7d0e..9fc59b96cf 100644
--- a/src/components/Message/MessageTimestamp.tsx
+++ b/src/components/Message/MessageTimestamp.tsx
@@ -3,6 +3,7 @@ import React, { useContext } from 'react';
 import { MessageContext } from '../../context/MessageContext';
 import { Timestamp as DefaultTimestamp } from './Timestamp';
 import { useComponentContext } from '../../context';
+import { requireContext } from '../../context/requireContext';
 
 import type { LocalMessage } from 'stream-chat';
 import type { TimestampFormatterOptions } from '../../i18n/types';
@@ -16,11 +17,13 @@ export type MessageTimestampProps = TimestampFormatterOptions & {
 
 const UnMemoizedMessageTimestamp = (props: MessageTimestampProps) => {
   const { message: propMessage, ...timestampProps } = props;
-  // with a `message` prop it also renders outside a message (e.g. the gallery header)
-  const { message: contextMessage } = useContext(MessageContext) ?? {};
+  // With a `message` prop it also renders outside a message (e.g. the gallery header). Without one
+  // it needs the surrounding message, and says so like `useMessageContext()` does.
+  const messageContext = useContext(MessageContext);
   const { Timestamp = DefaultTimestamp } = useComponentContext();
-  const message = propMessage || contextMessage;
-  if (!message) return null;
+  const message =
+    propMessage ||
+    requireContext(messageContext, 'MessageTimestamp', 'MessageProvider').message;
   return (
     <Timestamp
       timestamp={convertTimestampToDate(message.created_at)}
diff --git a/src/components/Message/__tests__/MessageTimestamp.test.tsx b/src/components/Message/__tests__/MessageTimestamp.test.tsx
index 11e562cb6f..6f49716a66 100644
--- a/src/components/Message/__tests__/MessageTimestamp.test.tsx
+++ b/src/components/Message/__tests__/MessageTimestamp.test.tsx
@@ -243,6 +243,33 @@ describe('<MessageTimestamp />', () => {
     expect(container.children).toHaveLength(0);
   });
 
+  it('should render from the message prop outside a MessageProvider', async () => {
+    let result: RenderResult;
+    await act(() => {
+      result = render(
+        <Chat client={getTestClient()}>
+          <MessageTimestamp customClass='outside-message' message={messageMock} />
+        </Chat>,
+      );
+    });
+    expect(result.container.querySelector('time.outside-message')).toHaveAttribute(
+      'datetime',
+      '2019-04-03T14:42:47.087Z',
+    );
+  });
+
+  it('should throw outside a MessageProvider without a message prop', () => {
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    expect(() =>
+      render(
+        <Chat client={getTestClient()}>
+          <MessageTimestamp />
+        </Chat>,
+      ),
+    ).toThrow(/MessageTimestamp was called outside of MessageProvider/);
+    vi.mocked(console.error).mockRestore();
+  });
+
   it('should render message with a custom css class when one is set', async () => {
     const customClass = 'custom-css-class';
     const { container } = await renderComponent({ props: { customClass } });
diff --git a/src/components/MessageList/MessageList.tsx b/src/components/MessageList/MessageList.tsx
index 5c1f8c5356..e66d4e2063 100644
--- a/src/components/MessageList/MessageList.tsx
+++ b/src/components/MessageList/MessageList.tsx
@@ -231,7 +231,16 @@ const MessageListWithContext = (props: MessageListWithContextProps) => {
   const canPaginateReplies = useCanPaginateReplies();
 
   const loadOlderMessages = React.useCallback(async () => {
-    if (loadingOlderRef.current) return;
+    // The paginator's own gate for a tailward page. Checked here too so that `isLoadingOlder`, which
+    // shows the older-page indicator, is never raised while another load (a jump, a newer page)
+    // holds `isLoading` and `toTail()` would not query.
+    if (
+      loadingOlderRef.current ||
+      messagePaginator.isLoading ||
+      !messagePaginator.hasMoreTail
+    ) {
+      return;
+    }
     loadingOlderRef.current = true;
     setIsLoadingOlder(true);
     try {
diff --git a/src/components/MessageList/__tests__/MessageList.test.tsx b/src/components/MessageList/__tests__/MessageList.test.tsx
index acdc378a97..a26b5dadc5 100644
--- a/src/components/MessageList/__tests__/MessageList.test.tsx
+++ b/src/components/MessageList/__tests__/MessageList.test.tsx
@@ -286,6 +286,9 @@ describe('MessageList', () => {
           internalInfiniteScrollProps: { loadNextDebounceMs: 0 },
         },
       });
+      act(() => {
+        channel.messagePaginator.state.partialNext({ hasMoreTail: true });
+      });
       const scroller = await screen.findByTestId('reverse-infinite-scroll');
       Object.defineProperty(scroller, 'offsetParent', {
         configurable: true,
@@ -332,6 +335,35 @@ describe('MessageList', () => {
       });
     });
 
+    it('does not request an older page while another load is in flight', async () => {
+      const toTail = vi.spyOn(channel.messagePaginator, 'toTail');
+      const { container } = renderComponent({
+        channelProps: { channel },
+        chatClient,
+        msgListProps: { internalInfiniteScrollProps: { loadNextDebounceMs: 0 } },
+      });
+      const scroller = await screen.findByTestId('reverse-infinite-scroll');
+      Object.defineProperty(scroller, 'offsetParent', {
+        configurable: true,
+        get: () => document.body,
+      });
+      act(() => {
+        // e.g. a jump to a message, or the newer page `scrollToBottom` asked for
+        channel.messagePaginator.state.partialNext({
+          hasMoreTail: true,
+          isLoading: true,
+        });
+      });
+
+      fireEvent.scroll(scroller);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(toTail).not.toHaveBeenCalled();
+      expect(
+        container.querySelector('.str-chat__list__loading .str-chat__loading-indicator'),
+      ).not.toBeInTheDocument();
+    });
+
     it('does not show the loading indicator while a newer page loads', async () => {
       const { container } = renderComponent({ channelProps: { channel }, chatClient });
       await screen.findByTestId('reverse-infinite-scroll');
diff --git a/src/context/ThemeScopeContext.tsx b/src/context/ThemeScopeContext.tsx
new file mode 100644
index 0000000000..0554436ba5
--- /dev/null
+++ b/src/context/ThemeScopeContext.tsx
@@ -0,0 +1,44 @@
+import clsx from 'clsx';
+import React, { createContext, useContext } from 'react';
+import type { PropsWithChildren } from 'react';
+
+import { useChatContext } from './ChatContext';
+
+/**
+ * Whether the subtree already renders inside an element carrying the `str-chat <theme>` scope that
+ * the design tokens hang off. `.str-chat` declares the whole token set, so a second one nested
+ * inside the first would reset every token an app overrides on the outer element. Components that
+ * also render standalone (the channel navigation, a channel list) therefore apply the scope only
+ * when nothing above them has.
+ */
+const ThemeScopeContext = createContext(false);
+
+/** Marks its subtree as rendering inside the `str-chat <theme>` scope. */
+export const ThemeScopeProvider = ({ children }: PropsWithChildren) => (
+  <ThemeScopeContext.Provider value={true}>{children}</ThemeScopeContext.Provider>
+);
+
+export const useIsInThemeScope = () => useContext(ThemeScopeContext);
+
+/** The scope's classes: `customClasses.chat` (default `str-chat`) and the `Chat` theme. */
+export const useThemeScopeClassName = () => {
+  const { customClasses, theme } = useChatContext();
+  return clsx(customClasses?.chat ?? 'str-chat', theme);
+};
+
+/**
+ * Renders its children inside the `str-chat <theme>` scope, adding a layout-neutral
+ * (`display: contents`) wrapper only when no ancestor provides the scope.
+ */
+export const ThemeScope = ({ children }: PropsWithChildren) => {
+  const isInThemeScope = useIsInThemeScope();
+  const themeScopeClassName = useThemeScopeClassName();
+
+  if (isInThemeScope) return <>{children}</>;
+
+  return (
+    <div className={clsx(themeScopeClassName, 'str-chat__theme-scope')}>
+      <ThemeScopeProvider>{children}</ThemeScopeProvider>
+    </div>
+  );
+};
diff --git a/src/plugins/SlotLayout/ChatView.tsx b/src/plugins/SlotLayout/ChatView.tsx
index 2d66b05fad..f430a49437 100644
--- a/src/plugins/SlotLayout/ChatView.tsx
+++ b/src/plugins/SlotLayout/ChatView.tsx
@@ -69,6 +69,7 @@ import type {
 } from './slotBinding';
 import { getLayoutViewState } from './hooks';
 import { requireContext } from '../../context/requireContext';
+import { ThemeScopeProvider } from '../../context/ThemeScopeContext';
 
 // Re-export the binding primitives + renderer types from their leaf modules so
 // existing `stream-chat-react` imports keep resolving through ChatView.
@@ -460,9 +461,11 @@ export const ChatView = ({
                     view content (context menus, member actions, …) portal here and inherit the
                     `.str-chat`-scoped dialog CSS. Nested managers (e.g. MessageList's) still win
                     where present. */}
-                <DialogManagerProvider id={dialogManagerId}>
-                  {content}
-                </DialogManagerProvider>
+                <ThemeScopeProvider>
+                  <DialogManagerProvider id={dialogManagerId}>
+                    {content}
+                  </DialogManagerProvider>
+                </ThemeScopeProvider>
                 {channelSlots.map(({ bindingKey, channel, slot }) => (
                   <SupersededChannelSwap
                     bindingKey={bindingKey}
diff --git a/src/plugins/SlotLayout/__tests__/ChatView.test.tsx b/src/plugins/SlotLayout/__tests__/ChatView.test.tsx
index c61b9bd93f..e54e9bf25a 100644
--- a/src/plugins/SlotLayout/__tests__/ChatView.test.tsx
+++ b/src/plugins/SlotLayout/__tests__/ChatView.test.tsx
@@ -11,6 +11,7 @@ import {
 import { ChatView } from '../ChatView';
 import { LayoutController } from '../layoutController/LayoutController';
 import { createChatViewSlotBinding } from '../slotBinding';
+import { useIsInThemeScope } from '../../../context/ThemeScopeContext';
 
 const renderSelector = async (selectorProps?: any) => {
   const client = await getTestClientWithUser();
@@ -63,6 +64,40 @@ const renderSelectorWithPanels = async (selectorProps?: any) => {
   );
 };
 
+describe('ChatView theme scope', () => {
+  afterEach(cleanup);
+
+  it('tells its content it already renders inside the str-chat theme scope', async () => {
+    const client = await getTestClientWithUser();
+    const ThemeScopeProbe = () => (
+      <div data-in-theme-scope={String(useIsInThemeScope())} data-testid='probe' />
+    );
+
+    render(
+      <ChatProvider
+        value={{
+          client,
+          getAppSettings: vi.fn(),
+          mutes: [],
+          searchController: fromPartial({}),
+          theme: 'messaging light',
+          useImageFlagEmojisOnWindows: false,
+        }}
+      >
+        <TranslationProvider value={mockTranslationContextValue()}>
+          <ChatView>
+            <ThemeScopeProbe />
+          </ChatView>
+        </TranslationProvider>
+      </ChatProvider>,
+    );
+
+    const probe = screen.getByTestId('probe');
+    expect(probe).toHaveAttribute('data-in-theme-scope', 'true');
+    expect(probe.closest('.str-chat')).toHaveClass('str-chat__chat-view');
+  });
+});
+
 describe('ChatView.Selector', () => {
   afterEach(() => {
     cleanup();
diff --git a/src/styling/base.scss b/src/styling/base.scss
index e753d2101e..03350900f2 100644
--- a/src/styling/base.scss
+++ b/src/styling/base.scss
@@ -33,3 +33,9 @@
     color: var(--str-chat__input-text-placeholder);
   }
 }
+
+// The wrapper a standalone component adds to get the `.str-chat` scope (tokens, font) when nothing
+// above it provides one. It must not take part in layout.
+.str-chat__theme-scope {
+  display: contents;
+}

From 7f9239d73421bc03f9e9264a08dc8180e0ad45e2 Mon Sep 17 00:00:00 2001
From: Oliver Lazoroski <oliver.lazoroski@gmail.com>
Date: Sat, 17 Oct 2026 12:24:24 +0200
Subject: [PATCH 3/5] docs: update the v15 audit and migration guide for the
 removed dead surface

---
 ai-docs/ai-migration-v14-v15.md | 109 ++++++++++++++++----------------
 ai-docs/v15-breaking-changes.md | 104 +++++++++++++++---------------
 2 files changed, 110 insertions(+), 103 deletions(-)

diff --git a/ai-docs/ai-migration-v14-v15.md b/ai-docs/ai-migration-v14-v15.md
index 90c2c273d8..244f977b9b 100644
--- a/ai-docs/ai-migration-v14-v15.md
+++ b/ai-docs/ai-migration-v14-v15.md
@@ -45,27 +45,26 @@ Then run the [silent-break checklist](#breaks-that-do-not-fail-to-compile) once
 
 These compile cleanly, or are ignored in plain JS, and change behavior at runtime. Check each one explicitly; the absence of an error does not mean the app is migrated.
 
-| Symptom                                                                                                                                    | Cause                                                                                                     | Fix                                                                                                                                    |
-| ------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| Clicking a channel-list row, a search result, a thread-list row or a message's reply button does nothing; no row shows active              | Selection and thread opening go through workspace navigation, whose default outside `ChatView` is a no-op | Use `ChatView`, or provide `WorkspaceNavigationProvider` ([section 4](#4-selecting-channels-and-opening-threads-workspace-navigation)) |
-| A channel renders empty, with no error, and gets no new messages                                                                           | `Channel` no longer watches the channel                                                                   | `await channel.ensureWatched()` before rendering it ([section 5](#channel-no-longer-watches-the-channel))                              |
-| A filtered or synthetic `messages` array passed to a message list is ignored                                                               | `MessageList.messages` / `VirtualizedMessageList.messages` still type-check but are never read            | `reviewProcessedMessage`, `hideDeletedMessages` or `renderMessages` ([section 11](#the-messages-prop-is-ignored))                      |
-| After a failed send, the composer is empty instead of holding the text and attachments                                                     | The composer is released before the request and nothing is put back                                       | Nothing to do; the failed message is retried from the list ([section 13](#a-failed-send-or-edit-no-longer-restores-the-composer))      |
-| A component that rendered blank outside its provider now throws                                                                            | Required context hooks throw instead of warning and returning `{}`                                        | Render it inside the provider ([section 10](#required-context-hooks-throw-outside-their-provider))                                     |
-| A standalone `<Message>` (a preview, a pinned-message card) throws                                                                         | `Message` needs a channel in context                                                                      | Wrap it in `ChannelInstanceProvider` ([section 12](#a-standalone-message-needs-a-channel-in-context))                                  |
-| The channel is not marked read                                                                                                             | Mark-read moved from `Channel` mount to the message list                                                  | Render a message list, or mark read yourself ([section 5](#markreadonmount-is-removed-the-list-marks-read))                            |
-| The tab title no longer shows `(3) Title`                                                                                                  | `Channel` no longer writes `document.title`                                                               | Write it in app code ([section 5](#channel-no-longer-writes-documenttitle))                                                            |
-| Mount effects in a channel's children stop re-running when the channel changes                                                             | `Channel` no longer remounts its subtree per channel                                                      | Depend on the `channel` instance ([section 5](#channel-lifecycle-activation-no-remount-no-reload-no-search-jump))                      |
-| Search results open unwatched, empty channels in a custom result component                                                                 | Search results are no longer watched                                                                      | `ensureWatched()` on open ([section 4](#search-results))                                                                               |
-| Translations or overrides stop applying; non-English UI renders English                                                                    | Keys renamed, non-English dictionaries removed                                                            | Rename keys, register dictionaries ([section 18](#18-i18n))                                                                            |
-| CSS on `.str-chat__main-panel`, `.str-chat__container`, `.str-chat__channel-list-inner` or `.str-chat__thread--virtualized` stops applying | Those wrappers and classes are gone                                                                       | Retarget ([section 19](#19-css-and-markup))                                                                                            |
-| Plain JS: `useCreateChatClient({ options })` stops applying `baseURL` and other settings                                                   | `options` was renamed to `config`                                                                         | [Section 2](#usecreatechatclient-options--config)                                                                                      |
-| Plain JS: a removed prop or override key (`Message`, `HeaderStartContent`, `do*Request`, `overrideSubmitHandler`, ...) does nothing        | Ignored without a warning                                                                                 | Grep for each removed name listed in this guide                                                                                        |
-| A supplied composer keeps its content after `MessageComposer` unmounts                                                                     | A supplied composer is never cleared on unmount                                                           | Call `composer.clear()` yourself ([section 13](#preventclearingonunmount-is-removed))                                                  |
-| A voice message stops another one playing in a different panel                                                                             | Playback is exclusive app-wide                                                                            | Nothing to do ([section 12](#allowconcurrentplayback-is-removed-one-voice-message-plays-at-a-time))                                    |
-| The attachment menu offers different actions than before                                                                                   | Actions follow the composer's resolved configuration                                                      | Set `customCdn` where it applies ([section 13](#attachment-and-poll-availability))                                                     |
-| A custom `MessageTimestamp` no longer shows in the gallery header                                                                          | The gallery renders its own timestamp                                                                     | Customize `timestamp.GalleryTimestamp` ([section 12](#the-gallery-header-ignores-the-messagetimestamp-override))                       |
-| `dayjs(created_at)` renders `Invalid Date`                                                                                                 | Server timestamps are unix nanoseconds                                                                    | Convert with `convertTimestampToDate` ([section 16](#16-dates-on-response-types-are-unix-nanosecond-numbers))                          |
+| Symptom                                                                                                                                    | Cause                                                                                                                                                        | Fix                                                                                                                                              |
+| ------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Clicking a channel-list row, a search result, a thread-list row or a message's reply button does nothing; no row shows active              | Selection and thread opening go through workspace navigation, whose default outside `ChatView` is a no-op (it logs a one-time console warning per operation) | Use `ChatView`, or provide `WorkspaceNavigationProvider` ([section 4](#4-selecting-channels-and-opening-threads-workspace-navigation))           |
+| A channel renders empty, with no error, and gets no new messages                                                                           | `Channel` no longer watches the channel                                                                                                                      | `await channel.ensureWatched()` before rendering it ([section 5](#channel-no-longer-watches-the-channel))                                        |
+| After a failed send, the composer is empty instead of holding the text and attachments                                                     | The composer is released before the request and nothing is put back                                                                                          | Nothing to do; the failed message is retried from the list ([section 13](#a-failed-send-or-edit-no-longer-restores-the-composer))                |
+| A component that rendered blank outside its provider now throws                                                                            | Required context hooks throw instead of warning and returning `{}`                                                                                           | Render it inside the provider ([section 10](#required-context-hooks-throw-outside-their-provider))                                               |
+| A standalone `<Message>` (a preview, a pinned-message card) throws                                                                         | `Message` needs a channel in context                                                                                                                         | Wrap it in `ChannelInstanceProvider` ([section 12](#a-standalone-message-needs-a-channel-in-context))                                            |
+| The channel is not marked read                                                                                                             | Mark-read moved from `Channel` mount to the message list                                                                                                     | Render a message list, or mark read yourself ([section 5](#markreadonmount-is-removed-the-list-marks-read))                                      |
+| The tab title no longer shows `(3) Title`                                                                                                  | `Channel` no longer writes `document.title`                                                                                                                  | Write it in app code ([section 5](#channel-no-longer-writes-documenttitle))                                                                      |
+| Mount effects in a channel's children stop re-running when the channel changes                                                             | `Channel` no longer remounts its subtree per channel                                                                                                         | Depend on the `channel` instance ([section 5](#channel-lifecycle-activation-no-remount-no-reload-no-search-jump))                                |
+| Search results open unwatched, empty channels in a custom result component                                                                 | Search results are no longer watched                                                                                                                         | `ensureWatched()` on open ([section 4](#search-results))                                                                                         |
+| Translations or overrides stop applying; non-English UI renders English                                                                    | Keys renamed, non-English dictionaries removed                                                                                                               | Rename keys, register dictionaries ([section 18](#18-i18n))                                                                                      |
+| CSS on `.str-chat__main-panel`, `.str-chat__container`, `.str-chat__channel-list-inner` or `.str-chat__thread--virtualized` stops applying | Those wrappers and classes are gone                                                                                                                          | Retarget ([section 19](#19-css-and-markup))                                                                                                      |
+| Plain JS: `useCreateChatClient({ options })` stops applying `baseURL` and other settings                                                   | `options` was renamed to `config`                                                                                                                            | [Section 2](#usecreatechatclient-options--config)                                                                                                |
+| Plain JS: a removed prop or override key (`Message`, `HeaderStartContent`, `do*Request`, `overrideSubmitHandler`, ...) does nothing        | Ignored without a warning                                                                                                                                    | Grep for each removed name listed in this guide                                                                                                  |
+| A supplied composer keeps its content after `MessageComposer` unmounts                                                                     | A supplied composer is never cleared on unmount                                                                                                              | Call `composer.clear()` yourself ([section 13](#preventclearingonunmount-is-removed))                                                            |
+| A voice message stops another one playing in a different panel                                                                             | Playback is exclusive app-wide                                                                                                                               | Nothing to do ([section 12](#allowconcurrentplayback-is-removed-one-voice-message-plays-at-a-time))                                              |
+| The attachment menu offers different actions than before                                                                                   | Actions follow the composer's resolved configuration                                                                                                         | Set `customCdn` where it applies ([section 13](#attachment-and-poll-availability))                                                               |
+| A custom `MessageTimestamp` does not show in the header of a gallery you build yourself                                                    | The gallery renders outside a message and reads the item; it uses the override only when the item carries its `message`                                      | Set `message` on each `GalleryItem` ([section 12](#the-gallery-header-renders-the-messagetimestamp-override-for-items-that-carry-their-message)) |
+| `dayjs(created_at)` renders `Invalid Date`                                                                                                 | Server timestamps are unix nanoseconds                                                                                                                       | Convert with `convertTimestampToDate` ([section 16](#16-dates-on-response-types-are-unix-nanosecond-numbers))                                    |
 
 ---
 
@@ -124,7 +123,7 @@ Each import below is now a compile error (`TS2305` / `TS2724`) and `undefined` i
 | `MESSAGE_ACTIONS`, `OPTIONAL_MESSAGE_ACTIONS`, `getMessageActions`, `MessageActionsArray`, `Capabilities`                                                                        | [Section 10](#messageactions-and-message_actions-are-removed)                             |
 | `deTranslations` ... `trTranslations`, `enTranslations`, `isLanguageSupported`, `SupportedTranslations`, `DateFormatterOptions`                                                  | [Section 18](#18-i18n)                                                                    |
 
-`useMessagePaginator` is not exported from `stream-chat-react` either (it is internal). Read the active list's paginator as `(thread ?? channel).messagePaginator`, with `channel` from `useChannel()` and `thread` from `useThreadContext()`.
+New root exports: `useMessagePaginator()` returns the active list's paginator (the thread's inside a thread, the channel's otherwise), and `useIsCooldownActive()` tells whether slow mode is counting down.
 
 ---
 
@@ -378,9 +377,9 @@ In v14, `ChatContext.setActiveChannel` selected a channel and `ChannelActionCont
 - `ChannelHeader` / `ThreadHeader` back and close buttons: `canGoBack`, `goBack`, `isChannelDismissable`, `isThreadDismissable`
 - `ChannelListHeader` shows `HeaderEndContent` only while `openChannels` is non-empty
 
-**Outside `ChatView` the default navigation is an inert no-op**, so all of the above does nothing: clicking a row opens nothing, no row is marked active, and the header buttons do not render. This is the most common silent break of the upgrade.
+The channel-detail "send direct message" member action and the pinned-message entry (from `stream-chat-react/channel-detail`) call `openChannel(channel)` too.
 
-The channel-detail "send direct message" member action and the pinned-message entry (from `stream-chat-react/channel-detail`) call `useChatViewNavigation().open` from `stream-chat-react/slot-layout` instead. They work only inside `ChatView`; a custom `WorkspaceNavigationProvider` does not reach them.
+**Outside `ChatView` the default navigation is an inert no-op**, so all of the above does nothing: clicking a row opens nothing, no row is marked active, and the header buttons do not render. This is the most common silent break of the upgrade. Each operation (`openChannel`, `openThread`, `closeChannel`, `closeThread`, `goBack`) logs a one-time console warning when it runs with no navigation provided. `defaultWorkspaceNavigation` itself stays silent, so a provider built by spreading it does not warn.
 
 ### Inside `ChatView`
 
@@ -514,7 +513,7 @@ export const App = ({ client, userId }: { client: StreamChat; userId: string })
 ### `Message.openThread` and the lists' `openThread`
 
 - `MessageList.openThread`, `VirtualizedMessageList.openThread` and `VirtuosoContext.openThread` are removed.
-- `Message.openThread` remains, typed `(message: LocalMessage, event: BaseSyntheticEvent) => void` (the event is now required: a caller passing no event fails with `TS2554`). Lists no longer drill it, so it applies only to a `<Message>` you render yourself, and there only to the reply action. The reply-count button calls `useWorkspaceNavigation().openThread` itself and no longer honors it.
+- `Message.openThread` remains, typed `(message: LocalMessage, event: BaseSyntheticEvent) => void` (the event is now required: a caller passing no event fails with `TS2554`). Lists no longer drill it, so it applies only to a `<Message>` you render yourself. There, both the reply action and the reply-count button honor it: `MessageRepliesCountButton` without an `onClick` calls the message's `handleOpenThread`. Without an override, both open the thread through workspace navigation.
 
 ---
 
@@ -525,7 +524,7 @@ export const App = ({ client, userId }: { client: StreamChat; userId: string })
 ### `Channel` requires `channel` and renders no placeholder, loading or error state
 
 - `ChannelProps.channel` is required (`TS2741` without it). `Channel` no longer picks the channel up from `ChatContext`; in plain JS a missing channel crashes (`channel.activate` of `undefined`).
-- `EmptyPlaceholder` is removed, and `Channel` no longer renders `EmptyStateIndicator` (`listType='message'`) when nothing is selected, nor `LoadingIndicator` / `LoadingErrorIndicator`. `ComponentContext.LoadingErrorIndicator` is still declared but read by no SDK component.
+- `EmptyPlaceholder` is removed, and `Channel` no longer renders `EmptyStateIndicator` (`listType='message'`) when nothing is selected, nor `LoadingIndicator` / `LoadingErrorIndicator`. The `ComponentContext.LoadingErrorIndicator` slot is removed (a compile error in `WithComponents` overrides); the `LoadingErrorIndicator` component is still exported for your own error UI.
 - Guard at the call site, and render the new `ChannelPlaceholder` (the same `.str-chat__channel` column, `children` allowed) while nothing is selected. Render loading and error UI yourself, around `Channel`.
 
 ```tsx
@@ -774,7 +773,7 @@ A single list can still be rendered on its own with `<ChannelList paginator={pag
 | `ListItem`                  | `{ item }`              | renders `ChannelListItem` |
 | `LoadingNextPageIndicator`  | `{ isLoading? }`        |                           |
 
-`ComponentContext.LoadingIndicator` / `LoadingErrorIndicator` no longer affect the channel list, and query errors are reported as a notification. For a fully custom list, read `useChannelPaginatorState(paginator)` and render your own.
+`ComponentContext.LoadingIndicator` no longer affects the channel list (the `LoadingErrorIndicator` slot is removed, [section 5](#channel-requires-channel-and-renders-no-placeholder-loading-or-error-state)), and query errors are reported as a notification. For a fully custom list, read `useChannelPaginatorState(paginator)` and render your own.
 
 ```tsx
 // v14
@@ -1265,12 +1264,13 @@ These are `stream-chat` changes, documented in its own migration notes. They are
 
 A stale key in `WithComponents overrides` is a compile error (`TS2353` / `TS2561`). In plain JS or behind `any` it is ignored with no warning, and the default UI renders (or nothing, for `HeaderStartContent`).
 
-| Removed slot         | v15                                                                                                                       |
-| -------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| `Message`            | `MessageUI` ([below](#message-ui-overrides-consolidate-on-the-messageui-slot))                                            |
-| `ThreadHeader`       | Render `<ThreadHeader />` (or your own) as a child of `<Thread>` ([section 7](#threadheader-lost-closethread-and-thread)) |
-| `HeaderStartContent` | `StartContent` on `ChannelHeader` / `ThreadHeader` ([section 8](#8-channel-and-thread-headers))                           |
-| `ChannelListUI`      | The list slots ([section 6](#channellistui-is-removed-use-the-list-slots))                                                |
+| Removed slot            | v15                                                                                                                                                               |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Message`               | `MessageUI` ([below](#message-ui-overrides-consolidate-on-the-messageui-slot))                                                                                    |
+| `ThreadHeader`          | Render `<ThreadHeader />` (or your own) as a child of `<Thread>` ([section 7](#threadheader-lost-closethread-and-thread))                                         |
+| `HeaderStartContent`    | `StartContent` on `ChannelHeader` / `ThreadHeader` ([section 8](#8-channel-and-thread-headers))                                                                   |
+| `ChannelListUI`         | The list slots ([section 6](#channellistui-is-removed-use-the-list-slots))                                                                                        |
+| `LoadingErrorIndicator` | Render the exported `LoadingErrorIndicator` yourself, around `Channel` ([section 5](#channel-requires-channel-and-renders-no-placeholder-loading-or-error-state)) |
 
 `WithComponents` merges over the parent context and merges `icons` slot by slot. `Channel`, `Thread`, the message lists and `MessageComposer` take no component overrides of their own.
 
@@ -1435,21 +1435,20 @@ export const List = () => (
 
 Both lists drive themselves from `(thread ?? channel).messagePaginator`.
 
-### The `messages` prop is ignored
+### The `messages` prop is removed
 
-`MessageList.messages` and `VirtualizedMessageList.messages` still type-check, and the `VirtualizedMessageList` doc comment still says it overrides the messages, but **both lists always render the active paginator's items.** A custom array (filtered, reordered or synthetic) is dropped with no error.
+`MessageList.messages` and `VirtualizedMessageList.messages` are removed (a compile error). **Both lists always render the active paginator's items**; a custom array (filtered, reordered or synthetic) has no prop to go through.
 
 - To change what is rendered: `reviewProcessedMessage` (still applied by both lists), `hideDeletedMessages`, or a custom `renderMessages` (`MessageList`).
 - To change the data: act on the paginator (`messagePaginator.ingestItem(message)` / `removeItem({ id })`).
 - Do not reorder; the paginator owns the sort order.
 
-### Pagination and state props are removed or ignored
+### Pagination and state props are removed
 
 | Prop                                                                                                                                                                                | v15                                                                                                                                                                                                         |
 | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `MessageList`: `loadMore`, `loadMoreNewer`, `loadingMoreForJumpToChannelMessage`                                                                                                    | Removed                                                                                                                                                                                                     |
-| `MessageList`: `hasMore`, `jumpToLatestMessage`, `loadingMoreNewer`, `messageLimit`                                                                                                 | **Still typed, never read**                                                                                                                                                                                 |
-| `MessageList.loadingMore`                                                                                                                                                           | Only gates the `LoadingIndicator` in the "loading older" row, which renders while `messagePaginator.state.isLoading` is true                                                                                |
+| `MessageList`: `loadMore`, `loadMoreNewer`, `loadingMoreForJumpToChannelMessage`, `hasMore`, `jumpToLatestMessage`, `loadingMoreNewer`, `messageLimit`                              | Removed                                                                                                                                                                                                     |
+| `MessageList.loadingMore`                                                                                                                                                           | Kept. The `LoadingIndicator` above the messages shows while an older page loads; pass `loadingMore={false}` to hide it                                                                                      |
 | `MessageList.internalInfiniteScrollProps`                                                                                                                                           | Now feeds `InfiniteScrollPaginator`: `hasNextPage`, `hasPreviousPage`, `head`, `initialLoad`, `isLoading`, `loader`, `loadNextPage`, `loadPreviousPage`, `reverse` and `LoadingIndicator` no longer compile |
 | `VirtualizedMessageList`: `hasMore`, `hasMoreNewer`, `loadingMore`, `loadingMoreNewer`, `loadMore`, `loadMoreNewer`, `messageLimit`, `highlightedMessageId`, `channelUnreadUiState` | Removed                                                                                                                                                                                                     |
 
@@ -1619,9 +1618,13 @@ export const Stop = ({ channel }: { channel: Channel }) => {
 - Switching channels stops that channel's audio: `Channel` passes its channel as `WithAudioPlayback`'s new `playbackScope`, whose change clears the pool.
 - A custom `WithAudioPlayback` joins the shared arbiter that `Chat` provides automatically. Pass `playbackScope` if the provider outlives the entity it plays for.
 
-### The gallery header ignores the `MessageTimestamp` override
+### The gallery header renders the `MessageTimestamp` override for items that carry their message
 
-A custom `ComponentContext.MessageTimestamp` no longer appears in the gallery modal header, which renders the item's own timestamp through the `timestamp.GalleryTimestamp` key. Customize that key's format instead.
+The gallery renders outside any message, so its header reads the current item. When `ComponentContext.MessageTimestamp` is overridden and the item carries its `message` (a new optional `GalleryItem` field), the header renders the override with `customClass='str-chat__gallery__timestamp'`. Otherwise it renders its own timestamp through the `timestamp.GalleryTimestamp` key.
+
+- `ModalGallery` (attachments in a message) and the channel-detail media view fill `message`; set it yourself on gallery items you build.
+- To change only the format, customize `timestamp.GalleryTimestamp`.
+- `MessageTimestamp` renders from its `message` prop outside a `MessageProvider`; without the prop it still requires one.
 
 ---
 
@@ -2057,15 +2060,15 @@ Four formatter keys carry English day words inside their `calendarFormats` (`tim
 
 ## 19. CSS and markup
 
-| v14 markup or class                                                                                                        | v15                                                                                                                                                                                                                                                                                                                                                                                                      |
-| -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `div.str-chat__main-panel` (+ `--thread-open`), rendered by `Window`                                                       | Gone. `Channel` renders `div.str-chat__channel` as the content column (flex column with header, list, composer). Target `.str-chat__thread-container` / `.str-chat__thread` for the thread panel. The v14 getting-started CSS on `#root .str-chat__main-panel` matches nothing.                                                                                                                          |
-| `div.str-chat__container` inside `Channel` (or `customClasses.chatContainer`)                                              | Gone. `customClasses.chatContainer` is still in the type but applied nowhere; remove it.                                                                                                                                                                                                                                                                                                                 |
-| `.str-chat__channel-list-inner`, `.str-chat__channel-list-inner__main` (from `ChannelListUI`, which held `role="listbox"`) | Gone. Target `.str-chat__channel-list .str-chat__infinite-scroll-paginator` (the `role="listbox"` scroll container, inside `ChannelNavigation`) and `.str-chat__infinite-scroll-paginator__content`. A bare `<ChannelList>` has no `.str-chat__channel-list` ancestor.                                                                                                                                   |
-| The channel list root carried `str-chat <theme> str-chat__channel-list` and `customClasses.channelList`                    | `ChannelList` renders no wrapper of its own; `ChannelNavigation` renders `str-chat__channel-list`, and the `str-chat <theme>` scope comes from the `ChatView` root (or `Channel`). A list outside `ChatView` with no `.str-chat` ancestor gets no design tokens: wrap it in an element with `className={clsx('str-chat', theme)}`. `customClasses.channelList` is not applied; use a CSS-layer override. |
-| `.str-chat__chat-view__channels` / `.str-chat__chat-view__threads`                                                         | Rendered only when `ChatView` is given `views`. With the built-in workspace layout, content sits in `.str-chat__chat-view__workspace-layout`, `.str-chat__chat-view__workspace-layout-slots`, `.str-chat__chat-view__slot` (`--hidden`) and `.str-chat__chat-view__slot-layer`.                                                                                                                          |
-| `.str-chat__thread--virtualized` on the thread container                                                                   | Not applied. Scope by the list you render (`.str-chat__thread .str-chat__virtual-list`, or your own class).                                                                                                                                                                                                                                                                                              |
-| `.str-chat__quoted-message-preview` text inherited the surrounding colour                                                  | It sets `color: var(--str-chat__chat-text-incoming)`, and `--own` `var(--str-chat__chat-text-outgoing)`, matching the bubble backgrounds. In the default light theme your own quotes change to the outgoing bubble's text colour. Remove contrast workarounds written for v14; theme with those two tokens.                                                                                              |
+| v14 markup or class                                                                                                        | v15                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `div.str-chat__main-panel` (+ `--thread-open`), rendered by `Window`                                                       | Gone. `Channel` renders `div.str-chat__channel` as the content column (flex column with header, list, composer). Target `.str-chat__thread-container` / `.str-chat__thread` for the thread panel. The v14 getting-started CSS on `#root .str-chat__main-panel` matches nothing.                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `div.str-chat__container` inside `Channel` (or `customClasses.chatContainer`)                                              | Gone, and `customClasses.chatContainer` is removed from the type. Use `customClasses.channel` for the `.str-chat__channel` column.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `.str-chat__channel-list-inner`, `.str-chat__channel-list-inner__main` (from `ChannelListUI`, which held `role="listbox"`) | Gone. Target `.str-chat__channel-list .str-chat__infinite-scroll-paginator` (the `role="listbox"` scroll container, inside `ChannelNavigation`) and `.str-chat__infinite-scroll-paginator__content`. A bare `<ChannelList>` has no `.str-chat__channel-list` ancestor.                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| The channel list root carried `str-chat <theme> str-chat__channel-list` and `customClasses.channelList`                    | Inside `ChatView` the `str-chat <theme>` scope comes from the `ChatView` root, and the channel list adds none of its own: a nested `.str-chat` would reset the tokens you override on the `ChatView` root. Outside `ChatView`, `ChannelNavigation`'s root renders `str-chat <theme> str-chat__channel-list`, and a bare `<ChannelList>` wraps itself in `div.str-chat.<theme>.str-chat__theme-scope` (`display: contents`). `customClasses.chat` replaces `str-chat` where the scope is applied; `customClasses.channelList` replaces `str-chat__channel-list` on `ChannelNavigation`'s root. App CSS that targeted the list root as a `.str-chat` element no longer matches it inside `ChatView`. |
+| `.str-chat__chat-view__channels` / `.str-chat__chat-view__threads`                                                         | Rendered only when `ChatView` is given `views`. With the built-in workspace layout, content sits in `.str-chat__chat-view__workspace-layout`, `.str-chat__chat-view__workspace-layout-slots`, `.str-chat__chat-view__slot` (`--hidden`) and `.str-chat__chat-view__slot-layer`.                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `.str-chat__thread--virtualized` on the thread container                                                                   | Not applied. Scope by the list you render (`.str-chat__thread .str-chat__virtual-list`, or your own class).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `.str-chat__quoted-message-preview` text inherited the surrounding colour                                                  | It sets `color: var(--str-chat__chat-text-incoming)`, and `--own` `var(--str-chat__chat-text-outgoing)`, matching the bubble backgrounds. In the default light theme your own quotes change to the outgoing bubble's text colour. Remove contrast workarounds written for v14; theme with those two tokens.                                                                                                                                                                                                                                                                                                                                                                                        |
 
 Consumers keep overriding through CSS layers (see `README.md`); never edit compiled CSS.
 
@@ -2139,8 +2142,8 @@ Consumers keep overriding through CSS layers (see `README.md`); never edit compi
 | BC-043 | `MessageContext.mutes` / `messageIsUnread` removed                             | [12](#messagecontextmutes-and-messageisunread-are-removed)                                                  |
 | BC-044 | `retrySendMessage`, `useRetryHandler`                                          | [12](#retrysendmessage-and-useretryhandler)                                                                 |
 | BC-045 | Opening a thread from a message                                                | [4](#messageopenthread-and-the-lists-openthread)                                                            |
-| BC-046 | List pagination and state props                                                | [11](#pagination-and-state-props-are-removed-or-ignored)                                                    |
-| BC-047 | `messages` prop ignored                                                        | [11](#the-messages-prop-is-ignored)                                                                         |
+| BC-046 | List pagination and state props                                                | [11](#pagination-and-state-props-are-removed)                                                               |
+| BC-047 | `messages` prop removed                                                        | [11](#the-messages-prop-is-removed)                                                                         |
 | BC-048 | `threadList` / `head` removed                                                  | [11](#threadlist-and-head-are-removed-lists-detect-the-thread)                                              |
 | BC-049 | `withDateSeparator`                                                            | [11](#disabledateseparator--withdateseparator)                                                              |
 | BC-050 | `AIStates` from `stream-chat`                                                  | [12](#aistates-moved-to-stream-chat)                                                                        |
@@ -2152,7 +2155,7 @@ Consumers keep overriding through CSS layers (see `README.md`); never edit compi
 | BC-056 | `headerPosition` / `insertIntro` in nanoseconds                                | [11](#headerposition-and-insertintro-take-unix-nanoseconds)                                                 |
 | BC-057 | `DateSeparatorMessage`                                                         | [11](#dateseparatormessage)                                                                                 |
 | BC-058 | Standalone `Message` needs a channel                                           | [12](#a-standalone-message-needs-a-channel-in-context)                                                      |
-| BC-059 | Gallery header timestamp                                                       | [12](#the-gallery-header-ignores-the-messagetimestamp-override)                                             |
+| BC-059 | Gallery header timestamp                                                       | [12](#the-gallery-header-renders-the-messagetimestamp-override-for-items-that-carry-their-message)          |
 | BC-060 | `overrideSubmitHandler` removed                                                | [13](#overridesubmithandler-is-removed)                                                                     |
 | BC-061 | `preventClearingOnUnmount` removed                                             | [13](#preventclearingonunmount-is-removed)                                                                  |
 | BC-062 | `handleSubmit` removed                                                         | [13](#handlesubmit-is-removed)                                                                              |
diff --git a/ai-docs/v15-breaking-changes.md b/ai-docs/v15-breaking-changes.md
index 986b9a2174..8f7dc79b49 100644
--- a/ai-docs/v15-breaking-changes.md
+++ b/ai-docs/v15-breaking-changes.md
@@ -112,8 +112,8 @@ yarn api-surface check --doc ai-docs/v15-breaking-changes.md --diff diff.json
 | [BC-043](#bc-043) | `MessageContext.mutes` and `MessageContext.messageIsUnread` removed                                                                                                                                                           | Messages and message lists                           |
 | [BC-044](#bc-044) | `retrySendMessage` prop removed; `useRetryHandler` takes no argument and returns a params-object handler                                                                                                                      | Messages and message lists                           |
 | [BC-045](#bc-045) | opening a thread from a message goes through workspace navigation; `openThread` is gone from the lists and does nothing without a navigation provider                                                                         | Messages and message lists                           |
-| [BC-046](#bc-046) | list pagination and state props removed or ignored; the lists read the message paginator                                                                                                                                      | Messages and message lists                           |
-| [BC-047](#bc-047) | `MessageList.messages` / `VirtualizedMessageList.messages` are ignored                                                                                                                                                        | Messages and message lists                           |
+| [BC-046](#bc-046) | list pagination and state props removed; the lists read the message paginator                                                                                                                                                 | Messages and message lists                           |
+| [BC-047](#bc-047) | `MessageList.messages` / `VirtualizedMessageList.messages` are removed                                                                                                                                                        | Messages and message lists                           |
 | [BC-048](#bc-048) | thread-specific list props `threadList` and `head` removed; lists detect the thread from context                                                                                                                              | Messages and message lists                           |
 | [BC-049](#bc-049) | `disableDateSeparator` renamed to `withDateSeparator` (inverted)                                                                                                                                                              | Messages and message lists                           |
 | [BC-050](#bc-050) | `AIStates` is exported by `stream-chat`, not `stream-chat-react`                                                                                                                                                              | Messages and message lists                           |
@@ -125,7 +125,7 @@ yarn api-surface check --doc ai-docs/v15-breaking-changes.md --diff diff.json
 | [BC-056](#bc-056) | `MessageList.headerPosition` / `insertIntro` take unix nanoseconds (`TimestampNS`)                                                                                                                                            | Messages and message lists                           |
 | [BC-057](#bc-057) | `DateSeparatorMessage` (in the `RenderedMessage` union) lost `type`; `unread` is optional                                                                                                                                     | Messages and message lists                           |
 | [BC-058](#bc-058) | a standalone `<Message>` needs a channel in context; `highlighted` is no longer derived from channel state                                                                                                                    | Messages and message lists                           |
-| [BC-059](#bc-059) | the gallery header ignores the `MessageTimestamp` override                                                                                                                                                                    | Messages and message lists                           |
+| [BC-059](#bc-059) | the gallery header renders the `MessageTimestamp` override only for items that carry their message                                                                                                                            | Messages and message lists                           |
 | [BC-060](#bc-060) | `MessageComposer.overrideSubmitHandler` was removed                                                                                                                                                                           | Message composer                                     |
 | [BC-061](#bc-061) | `MessageComposer.preventClearingOnUnmount` was removed; a supplied composer is never cleared on unmount                                                                                                                       | Message composer                                     |
 | [BC-062](#bc-062) | `handleSubmit` was removed from `MessageComposerContext` and `useMessageComposerBindings`; submit with `useMessageComposerSubmitFn()` or `messageComposer.send()` / `update()`                                                | Message composer                                     |
@@ -140,7 +140,7 @@ yarn api-surface check --doc ai-docs/v15-breaking-changes.md --diff diff.json
 | [BC-071](#bc-071) | message-area props typed with `stream-chat` types change shape with `stream-chat` v10 (umbrella)                                                                                                                              | Types that follow stream-chat v10 (umbrella entries) |
 | [BC-072](#bc-072) | composer prop and type changes that follow stream-chat v10 types (umbrella)                                                                                                                                                   | Types that follow stream-chat v10 (umbrella entries) |
 | [BC-073](#bc-073) | CSS, channel layout wrappers: `Window` and the `str-chat__main-panel` / `str-chat__container` wrappers are removed                                                                                                            | CSS and markup                                       |
-| [BC-074](#bc-074) | CSS, channel list: `ChannelListUI` wrappers removed, and the list root no longer carries `str-chat` / theme / `customClasses.channelList`                                                                                     | CSS and markup                                       |
+| [BC-074](#bc-074) | CSS, channel list: `ChannelListUI` wrappers removed; the theme scope moves to `ChatView`, with the channel list carrying its own only outside it                                                                              | CSS and markup                                       |
 | [BC-075](#bc-075) | CSS, ChatView: `str-chat__chat-view__channels` / `__threads` render only in `views` mode                                                                                                                                      | CSS and markup                                       |
 | [BC-076](#bc-076) | CSS, Thread: `str-chat__thread--virtualized` is no longer applied                                                                                                                                                             | CSS and markup                                       |
 | [BC-077](#bc-077) | quote and edit previews set their text colour from the matching bubble token                                                                                                                                                  | CSS and markup                                       |
@@ -830,7 +830,8 @@ A threads view is declared the same way (a `{ id: 'threads', slots: [...] }` lay
 - Area: navigation
 - User impact:
   - compile error reading `setActiveChannel` / `channel` from `useChatContext()` (and from the return of `useChat()`); `undefined` in JS.
-  - silent behavior change: without `ChatView` (or your own `WorkspaceNavigationProvider`), clicking a `ChannelList` row, a channel/message/user search result, a `ThreadList` row, a message's reply-count button, "also sent in channel", or the channel-detail "send direct message" / pinned-message entry does nothing (these two call `useChatViewNavigation().open` from `slot-layout`, not `WorkspaceNavigation`, so they work only inside `ChatView`; a custom `WorkspaceNavigationProvider` does not reach them), and no list row renders as active (`ChannelListItem` derives `active` from `isChannelActive(cid)`, `ChannelListHeader` only shows `HeaderEndContent` while `openChannels` is non-empty).
+  - silent behavior change: without `ChatView` (or your own `WorkspaceNavigationProvider`), clicking a `ChannelList` row, a channel/message/user search result, a `ThreadList` row, a message's reply-count button, "also sent in channel", or the channel-detail "send direct message" / pinned-message entry does nothing, and no list row renders as active (`ChannelListItem` derives `active` from `isChannelActive(cid)`, `ChannelListHeader` only shows `HeaderEndContent` while `openChannels` is non-empty).
+  - with no navigation provided at all, each operation (`openChannel`, `openThread`, `closeChannel`, `closeThread`, `goBack`) logs a one-time console warning that nothing happened; `defaultWorkspaceNavigation` itself stays silent, so a provider built by spreading it does not warn.
   - `ChannelListItem` / `ChannelListItemUI` no longer accept `setActiveChannel` / `watchers` (BC-033).
 - Old API:
   - `ChatContextValue.setActiveChannel(newChannel?, watchers?, event?)`
@@ -846,7 +847,8 @@ A threads view is declared the same way (a `{ id: 'threads', slots: [...] }` lay
   - `release-v14:src/context/ChatContext.tsx:45-49` (`setActiveChannel`), `:54` (`channel?: Channel`); `release-v14:src/components/Chat/hooks/useChat.ts:116-131,137-144`
   - `master:src/context/ChatContext.tsx:27-46` (no `channel` / `setActiveChannel`); `master:src/components/Chat/hooks/useChat.ts:68-71`
   - `master:src/context/WorkspaceNavigationContext.tsx:84-139` (`WorkspaceNavigation`), `:145-159` (`defaultWorkspaceNavigation`, every operation a no-op), `:165-179` (`WorkspaceNavigationProvider`, `useWorkspaceNavigation`)
-  - consumers: `master:src/components/ChannelListItem/ChannelListItem.tsx:88`, `master:src/components/ChannelListItem/ChannelListItemUI.tsx:95-102`, `master:src/components/ChannelList/ChannelListHeader.tsx`, `master:src/components/Search/SearchResults/SearchResultItem.tsx:77,129,208`, `master:src/components/Message/hooks/useOpenThreadHandler.ts:17-32`, `master:src/components/Threads/ThreadList/ThreadListItemUI.tsx`, `master:src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx:222`, `master:src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx:143` (these two use `useChatViewNavigation().open`, whose default is a rejected no-op, `master:src/plugins/SlotLayout/ChatViewNavigationContext.tsx:211-222`)
+  - consumers: `master:src/components/ChannelListItem/ChannelListItem.tsx:88`, `master:src/components/ChannelListItem/ChannelListItemUI.tsx:95-102`, `master:src/components/ChannelList/ChannelListHeader.tsx`, `master:src/components/Search/SearchResults/SearchResultItem.tsx:77,129,208`, `master:src/components/Message/hooks/useOpenThreadHandler.ts:17-32`, `master:src/components/Threads/ThreadList/ThreadListItemUI.tsx`, `master:src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx:222,246`, `master:src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx:143,158` (both call `useWorkspaceNavigation().openChannel`; before `fix/v15-dead-surface-cleanup` they called `useChatViewNavigation().open` and so worked only inside `ChatView`)
+  - `master:src/context/WorkspaceNavigationContext.tsx:170-195` (the context default warns once per operation; `defaultWorkspaceNavigation` at `:145` does not)
   - commit: `99cbe6704` (PR #3237); `66557d63b` (PR #3301)
   - corpus: `examples/tutorial/src/6-custom-ui-components/App.tsx:44` TS2339 (`setActiveChannel` on `ChannelListItemUIProps`); `examples/vite/src/ChatLayout/Panels.tsx:145`, `examples/vite/src/Debug/ComposerStateDialog.tsx:39`, `examples/vite/src/Debug/StreamDebugHandles.tsx:25` (destructure `channel` from `useChatContext`)
 - Docs impact:
@@ -1094,15 +1096,17 @@ const client = useCreateChatClient({
 - Area: channel
 - User impact:
   - compile error rendering `<Channel>` without `channel` or with `EmptyPlaceholder` (`TS2741` / `TS2322`). In JS, a missing channel crashes (`channel.activate` of `undefined`).
-  - silent: `Channel` no longer picks the channel up from `ChatContext`, no longer renders `ComponentContext.EmptyStateIndicator` (`listType='message'`) when nothing is selected, and no longer renders `LoadingIndicator` / `LoadingErrorIndicator`. `ComponentContext.LoadingErrorIndicator` is read by no SDK component in v15.
+  - silent: `Channel` no longer picks the channel up from `ChatContext`, no longer renders `ComponentContext.EmptyStateIndicator` (`listType='message'`) when nothing is selected, and no longer renders `LoadingIndicator` / `LoadingErrorIndicator`.
+  - compile error on a `LoadingErrorIndicator` key in `WithComponents` overrides, or reading it from `useComponentContext()`: the `ComponentContextValue.LoadingErrorIndicator` slot is removed, since no SDK component rendered it in v15. The `LoadingErrorIndicator` component is still exported.
 - Old API:
   - `ChannelProps.channel?: Channel`
   - `ChannelProps.EmptyPlaceholder?: ReactElement | null`
-- Replacement: guard at the call site and render `ChannelPlaceholder` (new export; the same `.str-chat__channel` column, `children` allowed) while nothing is selected. Render your own loading/error UI around `Channel`.
+  - `ComponentContextValue.LoadingErrorIndicator?: ComponentType<LoadingErrorIndicatorProps>`
+- Replacement: guard at the call site and render `ChannelPlaceholder` (new export; the same `.str-chat__channel` column, `children` allowed) while nothing is selected. Render your own loading/error UI around `Channel`, using the exported `LoadingErrorIndicator` component if you like.
 - Evidence:
   - `release-v14:src/components/Channel/Channel.tsx:100,131,173-214` (context fallback, `EmptyPlaceholder`, `EmptyStateIndicator`, loading/error branches), `:1239-1252`
   - `master:src/components/Channel/Channel.tsx:17-23` (`channel: StreamChannel` only prop), `:29-44` (`ChannelPlaceholder`), `:48-103` (no loading/empty branches)
-  - `master:src/context/ComponentContext.tsx:181` (`LoadingErrorIndicator` slot still declared; `grep` finds no consumer outside `src/components/Loading`)
+  - `master:src/context/ComponentContext.tsx` declares no `LoadingErrorIndicator` slot (removed in `fix/v15-dead-surface-cleanup`; before that it was declared at `:181` with no consumer outside `src/components/Loading`)
   - commit: `088c795c1 feat(Channel)!: ...` (PR #3286)
 - Docs impact:
   - `02-ui-components/04-channel/01-channel.md`, `02-ui-components/04-channel/05-component_context.md`, `02-ui-components/06-thread-list/01-thread-list.md`, `06-release-guides/01-upgrade-to-v14.md`
@@ -1508,7 +1512,7 @@ A single list can still be rendered on its own with `<ChannelList paginator={pag
 
 - Status: confirmed
 - Area: channel list
-- User impact: compile errors on the import and on a `ChannelListUI` key in `WithComponents` overrides; in JS the override is ignored. `ComponentContext.LoadingIndicator` / `LoadingErrorIndicator` no longer affect the channel list (v14 `ChannelListUI` read them).
+- User impact: compile errors on the import and on a `ChannelListUI` key in `WithComponents` overrides; in JS the override is ignored. `ComponentContext.LoadingIndicator` no longer affects the channel list (v14 `ChannelListUI` read it and `LoadingErrorIndicator`, whose slot is now removed; see BC-019).
 - Old API:
   - `ChannelListUI` (`{ error, loadedChannels?, loading?, setChannels? }`), `ChannelListUIProps`
   - `ComponentContextValue.ChannelListUI`
@@ -2181,12 +2185,13 @@ export const RetryButton = () => {
 - Replacement:
   - Recommended: render the app inside `ChatView` from `stream-chat-react/slot-layout`, whose navigation opens the thread into its `thread` slot (see BC-011 / BC-012 / BC-013).
   - Without `ChatView`: provide your own `WorkspaceNavigation` with `WorkspaceNavigationProvider` (spread `defaultWorkspaceNavigation` and implement `openThread` / `closeThread`). Resolve a `{ channel, message }` target with `client.threads.ensure({ channel, parentMessage })` and render `<Thread thread={thread}>`.
-  - Per message: `Message.openThread` remains, typed `(message: LocalMessage, event: BaseSyntheticEvent) => void`. Lists no longer drill it, so it applies only to a `<Message>` you render yourself, and there only to the reply action (`handleOpenThread`). The reply-count button no longer honors it: `MessageRepliesCountButton` calls `useWorkspaceNavigation().openThread` itself, and `MessageUI` no longer passes `onClick={handleOpenThread}` (`release-v14:src/components/Message/MessageUI.tsx:235-236`, `master:src/components/Message/MessageRepliesCountButton.tsx:43,70-79`).
+  - Per message: `Message.openThread` remains, typed `(message: LocalMessage, event: BaseSyntheticEvent) => void`. Lists no longer drill it, so it applies only to a `<Message>` you render yourself, where both the reply action and the reply-count button honor it: `MessageRepliesCountButton` without an `onClick` calls the message's `handleOpenThread`, as v14's `MessageUI` did by passing `onClick={handleOpenThread}` (`release-v14:src/components/Message/MessageUI.tsx:235-236`). Without an override, both fall back to `useWorkspaceNavigation().openThread`.
 - Evidence:
   - `release-v14:src/components/Message/types.ts:60` `openThread?: ChannelActionContextValue['openThread']`; `release-v14:src/components/MessageList/MessageList.tsx:505` and `release-v14:src/components/MessageList/VirtualizedMessageList.tsx:88` drill `openThread`
   - `release-v14:src/components/Message/hooks/useOpenThreadHandler.ts:10` falls back to `useChannelActionContext().openThread`
   - `master:src/components/Message/types.ts:53` `openThread?: (message: LocalMessage, event: BaseSyntheticEvent) => void`
   - `master:src/components/Message/hooks/useOpenThreadHandler.ts:17` `useWorkspaceNavigation()`, `:32` `void openThread({ channel, message })`
+  - `master:src/components/Message/MessageRepliesCountButton.tsx` falls back to `MessageContext.handleOpenThread` when it has no `onClick` (restored in `fix/v15-dead-surface-cleanup`; before that it called `useWorkspaceNavigation().openThread` directly and ignored `Message.openThread`)
   - `master:src/context/WorkspaceNavigationContext.tsx:145` `defaultWorkspaceNavigation`, `:157` `openThread: () => undefined`, `:165` `WorkspaceNavigationProvider`
   - `master:src/plugins/SlotLayout/ChatViewNavigationContext.tsx:114` `client.threads.ensure({ channel, parentMessage })`
   - commit: `99cbe6704` (PR #3237, "Thread open/close behavior is routed through `useChatViewNavigation()`")
@@ -2270,18 +2275,16 @@ export const ChannelWithThread = ({ channel }: { channel: StreamChannel }) => {
 
 (Types and exports were checked against V15 source. The snippet has not been run in an app.)
 
-### BC-046: list pagination and state props removed or ignored; the lists read the message paginator
+### BC-046: list pagination and state props removed; the lists read the message paginator
 
-- Status: confirmed (except the `loadingMore` indicator sub-point, which is `likely`)
+- Status: confirmed
 - Area: MessageList / VirtualizedMessageList
 - User impact:
   - compile errors on the removed props
-  - **silent**: some props still type-check but are never read, so values passed to them do nothing
   - `internalInfiniteScrollProps` now feeds `InfiniteScrollPaginator`, not `InfiniteScroll`, so `InfiniteScroll`-only fields no longer compile
 - Old API:
-  - `MessageList`, removed: `loadMore`, `loadMoreNewer`, `loadingMoreForJumpToChannelMessage`
-  - `MessageList`, still typed but ignored in v15: `hasMore`, `jumpToLatestMessage`, `loadingMoreNewer`, `messageLimit` (diff: `default-changed` `jumpToLatestMessage`, `messageLimit` -> none). `messages` is also ignored; see BC-047.
-  - `MessageList.loadingMore`: in v15 it only gates the `LoadingIndicator` inside the "loading older" row, which renders while `messagePaginator.state.isLoading` is true. Without the prop, no indicator shows while older pages load (`likely` unintended; flag to maintainers).
+  - `MessageList`, removed: `loadMore`, `loadMoreNewer`, `loadingMoreForJumpToChannelMessage`, `hasMore`, `jumpToLatestMessage`, `loadingMoreNewer`, `messageLimit` (the last four stayed typed but unread on master until `fix/v15-dead-surface-cleanup` removed them; diff: `default-changed` `jumpToLatestMessage`, `messageLimit` -> none). `messages` is removed too; see BC-047.
+  - `MessageList.loadingMore` stays. The `LoadingIndicator` in the row above the messages shows while an older page loads (`props.loadingMore ?? isLoadingOlder`); pass `loadingMore={false}` to hide it. Before `fix/v15-dead-surface-cleanup` it showed only when the prop was passed.
   - `MessageList.internalInfiniteScrollProps`: `Partial<InfiniteScrollProps>` -> `InternalPaginatorProps` (`hasNextPage`, `hasPreviousPage`, `head`, `initialLoad`, `isLoading`, `loader`, `loadNextPage`, `loadPreviousPage`, `reverse`, `LoadingIndicator` no longer accepted)
   - `VirtualizedMessageList`, removed: `hasMore`, `hasMoreNewer`, `loadingMore`, `loadingMoreNewer`, `loadMore`, `loadMoreNewer`, `messageLimit`, `highlightedMessageId`, `channelUnreadUiState`
 - Replacement: both lists drive themselves from `(thread ?? channel).messagePaginator` (`channel` from `useChannel()`, `thread` from `useThreadContext()`). Code that drove these props should use the paginator directly:
@@ -2294,7 +2297,7 @@ export const ChannelWithThread = ({ channel }: { channel: StreamChannel }) => {
 - Evidence:
   - `release-v14:src/components/MessageList/MessageList.tsx:541` `loadingMoreForJumpToChannelMessage`, `:545` `loadMore`, `:547` `loadMoreNewer`, `:551` `messageLimit`; `:265`–`:275` forward `messageLimit` to `loadMore`
   - `release-v14:src/components/MessageList/VirtualizedMessageList.tsx:678` `channelUnreadUiState`, `:701` `hasMore`, `:703` `hasMoreNewer`, `:714` `highlightedMessageId`, `:716` `loadingMore`, `:718` `loadingMoreNewer`, `:720` `loadMore`, `:722` `loadMoreNewer`, `:728` `messageLimit`
-  - `master:src/components/MessageList/MessageList.tsx:469`–`:496` keeps `hasMore`, `jumpToLatestMessage`, `loadingMore`, `loadingMoreNewer`, `messageLimit` on the type. `MessageListWithContext` (`:82`) never reads them: `messageLimit` is commented out at `:97`, and the only use is `props.loadingMore` at `:399`.
+  - `master:src/components/MessageList/MessageList.tsx` `MessageListProps` keeps only `loadingMore` of these; `loadOlderMessages` raises `isLoadingOlder` only when a tailward page can load (`!isLoading && hasMoreTail`), and the loading row renders `(props.loadingMore ?? isLoadingOlder) && <LoadingIndicator />`. Before `fix/v15-dead-surface-cleanup` the type kept `hasMore`, `jumpToLatestMessage`, `loadingMoreNewer`, `messageLimit` unread, and the indicator required the prop.
   - `master:src/components/MessageList/MessageList.tsx:452` `InternalPaginatorProps`; `master:src/components/InfiniteScrollPaginator/InfiniteScrollPaginator.tsx:18` own props
   - `master:src/components/MessageList/VirtualizedMessageList.tsx:288` reads `messages`, `hasMoreNewer`, `isLoading` from `messagePaginator.state`
   - `node_modules/stream-chat/dist/types/pagination/paginators/MessageIntervalPaginator.d.ts:153` `messageFocusSignal`, `:279` `jumpToMessage`, `:280` `jumpToTheLatestMessage`; `MessagePaginator.d.ts:87` `unreadStateSnapshot`
@@ -2304,19 +2307,18 @@ export const ChannelWithThread = ({ channel }: { channel: StreamChannel }) => {
   - `02-ui-components/07-message-list/02-virtualized_list.md` (`hasMore`, `hasMoreNewer`, `loadMoreNewer`, `messageLimit`, `highlightedMessageId`, `channelUnreadUiState`)
 - Example needed: no
 
-### BC-047: `MessageList.messages` / `VirtualizedMessageList.messages` are ignored
+### BC-047: `MessageList.messages` / `VirtualizedMessageList.messages` are removed
 
 - Status: confirmed
 - Area: MessageList / VirtualizedMessageList
-- User impact: **silent behavior change**. The props still type-check, and the VML doc comment still says "override the messages", but both lists always render the active paginator's items. A custom message array (filtered, reordered or synthetic) is dropped without an error.
+- User impact: compile error on `messages`. Both lists always render the active paginator's items. On master before `fix/v15-dead-surface-cleanup` the props still type-checked and were silently ignored, so a custom message array (filtered, reordered or synthetic) was dropped without an error.
 - Old API:
   - `MessageList.messages` (v14 default `[]`, overriding `ChannelStateContext.messages`)
   - `VirtualizedMessageList.messages`
 - Replacement: there is no prop that replaces the source. To change what is rendered, use `reviewProcessedMessage` (still applied by both lists), `hideDeletedMessages`, or a custom `renderMessages` (`MessageList`). To change the data, act on the paginator (`messagePaginator.ingestItem` / `removeItem`). Do not reorder; the paginator owns the sort order.
 - Evidence:
   - `release-v14:src/components/MessageList/MessageList.tsx:104` `messages = []` read from props; `:605`–`:606` props spread over the channel state
-  - `master:src/components/MessageList/MessageList.tsx:498` `messages?: LocalMessage[]` on the type; `:135` `const { hasMoreNewer, isLoading, messages } = useStateStore(messagePaginator.state, …)`. The props are never read.
-  - `master:src/components/MessageList/VirtualizedMessageList.tsx:757` doc `Optional prop to override the messages…`; `:235` `// messages,` (destructuring commented out); `:288` `messages` from `messagePaginator.state`. The outer component passes `messages={props.messages}` (`:821`), but the inner list shadows it.
+  - `master:src/components/MessageList/MessageList.tsx` and `VirtualizedMessageList.tsx` read `messages` from `useStateStore(messagePaginator.state, …)` only; neither props type declares `messages` (removed in `fix/v15-dead-surface-cleanup`; before that both declared it and never read it).
   - diff: `default-changed MessageList.messages: [] => (none)`
   - commit: `99cbe6704` (PR #3237)
 - Docs impact:
@@ -2594,18 +2596,21 @@ export const Stop = ({ channel }: { channel: Channel }) => {
   - none found for a standalone `Message`
 - Example needed: no (the examples hunk is the reference)
 
-### BC-059: the gallery header ignores the `MessageTimestamp` override
+### BC-059: the gallery header renders the `MessageTimestamp` override only for items that carry their message
 
 - Status: confirmed
 - Area: Gallery
-- User impact: silent behavior change. A custom `ComponentContext.MessageTimestamp` no longer appears in the gallery modal header, which renders the item's own timestamp through the `timestamp.GalleryTimestamp` key.
+- User impact:
+  - The gallery renders outside any `MessageProvider`, so the header reads the item, not the surrounding message. When `ComponentContext.MessageTimestamp` is overridden and the item carries its `message`, the header renders the override (`customClass='str-chat__gallery__timestamp'`, `message={item.message}`). Otherwise it renders its own timestamp through the `timestamp.GalleryTimestamp` key.
+  - `ModalGallery` and the channel-detail media view fill `GalleryItem.message`. Items you build yourself need it for the override to apply.
+  - On master before `fix/v15-dead-surface-cleanup`, the header never used the override.
 - Old API:
   - `GalleryHeader` rendered `ComponentContext.MessageTimestamp` from the surrounding `MessageContext`
-- Replacement: none at the slot level. Customize the date format through the `timestamp.GalleryTimestamp` translation key.
+- Replacement: none needed for the default galleries. For hand-built gallery items, set `message` on each `GalleryItem` (new optional field). To change only the format, use the `timestamp.GalleryTimestamp` translation key. `MessageTimestamp` renders from its `message` prop outside a `MessageProvider`; without the prop it still requires one.
 - Evidence:
   - `release-v14:src/components/Gallery/GalleryHeader.tsx:23`, `:24`, `:50`
-  - `master:src/components/Gallery/GalleryHeader.tsx:27`, `:37` `timestampTranslationKey: 'timestamp.GalleryTimestamp'`, `:80`
-  - commit: `9194215f0` (PR #3267, "The gallery header no longer uses the `ComponentContext.MessageTimestamp` override")
+  - `master:src/components/Gallery/GalleryHeader.tsx` `{MessageTimestamp && message ? <MessageTimestamp … /> : <GalleryTimestamp createdAt={createdAt} />}`; `master:src/components/Gallery/GalleryContext.tsx` `GalleryItem.message?: LocalMessage`; `master:src/components/Attachment/ModalGallery.tsx` and `master:src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts` fill it
+  - commits: `9194215f0` (PR #3267, which dropped the override); `fix/v15-dead-surface-cleanup` (restores it for items carrying a message)
 - Docs impact:
   - none found
 - Example needed: no
@@ -3175,18 +3180,18 @@ export const DeleteForMe = () => {
 
 - Status: confirmed
 - Area: CSS / layout (Channel, Window)
-- User impact: app CSS targeting these wrappers silently stops applying. The v14 getting-started layout (`#root .str-chat__main-panel`, `.str-chat__main-panel--thread-open`) no longer matches anything. Importing `Window` / `WindowProps` is a compile error. `Chat`'s `customClasses.chatContainer` is still in the type but is applied nowhere.
+- User impact: app CSS targeting these wrappers silently stops applying. The v14 getting-started layout (`#root .str-chat__main-panel`, `.str-chat__main-panel--thread-open`) no longer matches anything. Importing `Window` / `WindowProps` is a compile error, and so is `customClasses.chatContainer` (`CustomClasses.chatContainer` is removed from the type).
 - Old API:
   - `Window`, `WindowProps` (rendered `div.str-chat__main-panel`, plus `--thread-open` while a thread was open; the prop doc names `str-chat__main-panel---with-thread-opn`)
   - `Channel` rendered its children inside `div.str-chat__container` (or `customClasses.chatContainer`)
   - stylesheet rules `.str-chat__channel .str-chat__container`, `.str-chat__container .str-chat__main-panel`, `.str-chat__main-panel` (removed from `dist/css/index.css`)
-- Replacement: none as a component. `Channel` renders `div.str-chat__channel` as its content column (flex column with header / list / composer), and the thread is a separate panel. Target `.str-chat__channel` for the channel column and `.str-chat__thread-container` / `.str-chat__thread` for the thread. For side-by-side panels, use `ChatView` slots (`str-chat__chat-view__slot`) from `stream-chat-react/slot-layout`, or your own layout. Remove `customClasses.chatContainer`.
+- Replacement: none as a component. `Channel` renders `div.str-chat__channel` as its content column (flex column with header / list / composer), and the thread is a separate panel. Target `.str-chat__channel` for the channel column and `.str-chat__thread-container` / `.str-chat__thread` for the thread. For side-by-side panels, use `ChatView` slots (`str-chat__chat-view__slot`) from `stream-chat-react/slot-layout`, or your own layout. Drop `customClasses.chatContainer`; use `customClasses.channel` for the channel column.
 - Evidence:
   - `release-v14:src/components/Window/Window.tsx:8-32` (`str-chat__main-panel`, `str-chat__main-panel--thread-open`)
   - `release-v14:src/components/Channel/Channel.tsx:249,1268` `<div className={clsx(chatContainerClass)}>{children}</div>` with `getChatContainerClass` defaulting to `str-chat__container`
   - `release-v14:src/components/Channel/styling/Channel.scss:8-40` `.str-chat__container`, `.str-chat__main-panel`; `release-v14:src/components/MessageList/styling/MessageList.scss:61` `.str-chat__main-panel`
   - `master:src/components/Channel/styling/Channel.scss:1-4`: "It used to wrap a `.str-chat__container` … and a `.str-chat__main-panel`; the thread is a slot now, so both wrappers are gone"
-  - `master:src/components/Channel/Channel.tsx:35-40` renders `str-chat <theme> str-chat__channel` with no inner container; `master:src/components/Channel/hooks/useChannelContainerClasses.ts:11,21` still computes `chatContainerClass`, which no component uses
+  - `master:src/components/Channel/Channel.tsx:35-40` renders `str-chat <theme> str-chat__channel` with no inner container; `master:src/context/ChatContext.tsx` `CSSClasses` has no `chatContainer`, and `useChannelContainerClasses` no longer computes `chatContainerClass` (both removed in `fix/v15-dead-surface-cleanup`; before that the key was typed and the class computed, but nothing applied it)
   - own class diff of `release-v14/dist/css/*.css` vs `master/dist/css/*.css` (comments stripped): exactly `str-chat__container` and `str-chat__main-panel` removed. `diff.md` reports 0 because the class names survive inside a CSS comment.
   - commit: `99cbe6704` (PR #3237)
   - corpus: `docs/02-ui-components__01-getting_started__1.tsx:7`, `docs/02-ui-components__03-chat__01-chat__5.tsx:10`, `docs/02-ui-components__04-channel__01-channel__4.tsx:11`, `docs/02-ui-components__08-message__13-date_separator__2.tsx:10` (`Window`, `TS2305`)
@@ -3194,26 +3199,26 @@ export const DeleteForMe = () => {
   - `02-ui-components/13-window.md` (whole page obsolete), `02-ui-components/01-getting_started.md` (CSS `#root .str-chat__main-panel` and `Window` usage), `02-ui-components/03-chat/01-chat.md` (`chatContainer -> str-chat__container`), and every page whose snippet wraps the list in `<Window>` (`02-ui-components/04-channel/01-channel.md`, `02-ui-components/08-message/13-date_separator.md`, …)
 - Example needed: no
 
-### BC-074: CSS, channel list: `ChannelListUI` wrappers removed, and the list root no longer carries `str-chat` / theme / `customClasses.channelList`
+### BC-074: CSS, channel list: `ChannelListUI` wrappers removed; the theme scope moves to `ChatView`, with the channel list carrying its own only outside it
 
-- Status: confirmed (markup); likely (visual impact of the missing `.str-chat` scope)
+- Status: confirmed
 - Area: CSS (ChannelList)
 - User impact:
-  - app CSS on `.str-chat__channel-list-inner` / `.str-chat__channel-list-inner__main` matches nothing (the SDK's own rules for them are dead too)
-  - `customClasses.channelList` (used in v14 theming docs to apply `str-chat__theme-dark`) is no longer applied
-  - in v14 the channel list root rendered `str-chat <theme> str-chat__channel-list` and so carried the design tokens itself. In v15 `ChannelList` renders no wrapper of its own, only the `InfiniteScrollPaginator` (`str-chat__infinite-scroll-paginator`, `role="listbox"`); the `str-chat__channel-list` root is rendered by `ChannelNavigation`, and the `str-chat <theme>` scope comes from the `ChatView` root (or `Channel`). A channel list rendered outside `ChatView` with no `.str-chat` ancestor gets no token variables.
+  - app CSS on `.str-chat__channel-list-inner` / `.str-chat__channel-list-inner__main` matches nothing. The SDK's own rules for them are removed too.
+  - in v14 the channel list root always rendered `str-chat <theme> str-chat__channel-list`. In v15 the `str-chat <theme>` scope comes from the `ChatView` root, and inside `ChatView` the channel list adds none of its own. `.str-chat` declares the whole token set, so a nested one would reset tokens overridden on the `ChatView` root. App CSS that relied on the list root being a `.str-chat` element (for example `.str-chat { … }` sizing rules) no longer matches it inside `ChatView`.
+  - outside `ChatView` the list carries the scope, as in v14. `ChannelNavigation`'s root renders `str-chat <theme> str-chat__channel-list`. A bare `<ChannelList paginator>` wraps itself in `div.str-chat.<theme>.str-chat__theme-scope`, which is `display: contents` and does not affect layout.
+  - `customClasses.chat` replaces `str-chat` wherever the scope is applied. `customClasses.channelList` replaces `str-chat__channel-list` on `ChannelNavigation`'s root, inside or outside `ChatView`.
 - Old API:
   - classes `str-chat__channel-list-inner`, `str-chat__channel-list-inner__main` (rendered by `ChannelListUI`, which held `role="listbox"`)
-  - `customClasses.channelList`; root classes `str-chat`, `theme`, `str-chat--windows-flags` on the channel list
-- Replacement: target `.str-chat__channel-list .str-chat__infinite-scroll-paginator` (inside `ChannelNavigation`; a bare `<ChannelList>` has no `.str-chat__channel-list` ancestor) (now the `role="listbox"` scroll container) and `.str-chat__infinite-scroll-paginator__content`. Put the list inside `ChatView`, or wrap it in an element with `className={clsx('str-chat', theme)}`. Use a CSS-layer override instead of `customClasses.channelList`.
+  - root classes `str-chat`, `theme`, `customClasses.channelList` (default `str-chat__channel-list`) and `str-chat--windows-flags` on the channel list
+- Replacement: target `.str-chat__channel-list .str-chat__infinite-scroll-paginator` (now the `role="listbox"` scroll container, inside `ChannelNavigation`) and `.str-chat__infinite-scroll-paginator__content`. Put overrides that must reach the channel list inside `ChatView` on the `ChatView` root (or `.str-chat` generally), not on a channel-list-specific `.str-chat` element.
 - Evidence:
   - `release-v14:src/components/ChannelList/ChannelListUI.tsx:38-41` `str-chat__channel-list-inner`, `__main` (`role='listbox'`)
   - `release-v14:src/components/ChannelList/ChannelList.tsx:341-357` root `clsx(customClasses?.chat ?? 'str-chat', theme, customClasses?.channelList ?? 'str-chat__channel-list', { 'str-chat--windows-flags': … })`
-  - `master:src/components/ChannelList/ChannelNavigation.tsx:35` root `<div className='str-chat__channel-list'>`; `master:src/components/ChannelList/ChannelList.tsx:86-99` `InfiniteScrollWithComponents` with `role='listbox'`; `master:src/components/InfiniteScrollPaginator/InfiniteScrollPaginator.tsx:157,171` its classes
-  - `master:src/plugins/SlotLayout/ChatView.tsx:458` `clsx('str-chat', theme, 'str-chat__chat-view')`
-  - `master:src/styling/variable-tokens.scss:4-6` tokens scoped to `.str-chat`
-  - `master:src/components/ChannelList/styling/ChannelList.scss:48,54` still styles the removed classes (dead rules)
-  - `rg 'customClasses\??\.channelList' master:src` returns no usage
+  - `master:src/context/ThemeScopeContext.tsx` (`ThemeScopeProvider`, `useIsInThemeScope`, `ThemeScope`); `master:src/plugins/SlotLayout/ChatView.tsx` wraps its content in `ThemeScopeProvider`
+  - `master:src/components/ChannelList/ChannelNavigation.tsx` root `clsx(!isInThemeScope && themeScopeClassName, customClasses?.channelList ?? 'str-chat__channel-list', windowsEmojiClass)`; `master:src/components/ChannelList/ChannelList.tsx` wraps the list in `<ThemeScope>`; `master:src/styling/base.scss` `.str-chat__theme-scope { display: contents }`
+  - `master:src/plugins/SlotLayout/ChatView.tsx` root `clsx('str-chat', theme, 'str-chat__chat-view')`; `master:src/styling/variable-tokens.scss:4-6` tokens scoped to `.str-chat`
+  - `fix/v15-dead-surface-cleanup`: before it, master rendered `ChannelNavigation`'s root as a bare `str-chat__channel-list`, applied `customClasses.channelList` nowhere, and kept dead `.str-chat__channel-list-inner` rules in `ChannelList.scss`
   - commit: `99cbe6704` (PR #3237)
 - Docs impact:
   - `02-ui-components/05-channel-list/06-channel-list-infinite-scroll.md`, `06-release-guides/01-upgrade-to-v14.md` (`str-chat__channel-list-inner`), `02-ui-components/02-theming/01-themingv2.md:172-173` (`customClasses.channelList`)
@@ -3369,7 +3374,7 @@ Non-gated items checked and ruled out: `Chat.isMessageAIGenerated`, `SummarizedM
 
 | Class                                                                                                 | Mapping                                                                                                                                                                                     |
 | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `str-chat__channel-list-inner`, `str-chat__channel-list-inner__main`                                  | BC-073                                                                                                                                                                                      |
+| `str-chat__channel-list-inner`, `str-chat__channel-list-inner__main`                                  | BC-074                                                                                                                                                                                      |
 | `str-chat__main-panel`, `str-chat__main-panel---with-thread-opn`, `str-chat__main-panel--thread-open` | BC-073 (with BC-010)                                                                                                                                                                        |
 | `str-chat__thread--virtualized`                                                                       | BC-073                                                                                                                                                                                      |
 | `str-chat__chat-view__channels`, `str-chat__chat-view__threads`                                       | ruled-out: false positive. v15 `ChatView` still renders them through a template literal (`master:src/plugins/SlotLayout/ChatView.tsx` ``className={`str-chat__chat-view__${activeView}`}``) |
@@ -3423,7 +3428,7 @@ Non-gated items checked and ruled out: `Chat.isMessageAIGenerated`, `SummarizedM
 | `Channel` no longer writes `document.title`; `activeUnreadHandler` -> removed                   | BC-021. Verified (did not verify `examples/vite/src/DocumentTitleManager` contents)                                                                                                                                                                             |
 | `channel.channelMissing.text` translation key -> removed                                        | BC-067 (i18n)                                                                                                                                                                                                                                                   |
 | `allowConcurrentAudioPlayback` -> removed                                                       | BC-051 (Channel prop); rest belongs to AudioPlayback area                                                                                                                                                                                                       |
-| `ChatContext.latestMessageDatesByChannels` -> removed                                           | BC-015. Inaccurate: names `useIsCooldownActive` as a replacement hook, but it is not exported (`master:src/components/MessageComposer/hooks/index.ts` exports only `useCooldownRemaining`; `useIsCooldownActive` is internal)                                   |
+| `ChatContext.latestMessageDatesByChannels` -> removed                                           | BC-015. Names `useIsCooldownActive` as a replacement hook; accurate since `fix/v15-dead-surface-cleanup` exported it from `src/components/MessageComposer/hooks/index.ts` (before that only `useCooldownRemaining` was public)                                  |
 | `Channel` no longer jumps to a searched message                                                 | BC-027, BC-039. Verified                                                                                                                                                                                                                                        |
 | `ChannelListItem` `getLatestMessagePreview` prop -> removed                                     | BC-033. Two inaccuracies (util still exported; no `Chat`/`Channel` component props)                                                                                                                                                                             |
 | `Thread` renders children; its composition props are removed                                    | BC-035. Inaccurate: `Thread` does not register the thread with the `ThreadManager`                                                                                                                                                                              |
@@ -3666,7 +3671,7 @@ Non-gated items checked and ruled out: `Chat.isMessageAIGenerated`, `SummarizedM
 - "Presentational props still take `Date`" -> ruled-out: no change (`DateSeparator.date: Date` unchanged)
 - "Peer-dependency gate before release", "Test fixtures have to model the wire" -> ruled-out: maintainer notes, not integrator breaks
 - "i18n: English-only bundle, namespaced translation keys" -> BC-067 (pointer only)
-- "Removed: `ChannelStateContext` / `ChannelActionContext` and their hooks" -> BC-003. Note: `useMessagePaginator` (pointed to by AGENTS.md and PR #3237) is not a public export.
+- "Removed: `ChannelStateContext` / `ChannelActionContext` and their hooks" -> BC-003. Note: `useMessagePaginator` (pointed to by AGENTS.md and PR #3237) is exported from the package root since `fix/v15-dead-surface-cleanup`; before that it was internal.
 - "Per-component request-handler props removed — register them on `client.config`" -> BC-023; related: BC-044
 
 #### `!` / BREAKING CHANGE commits touching this area
@@ -3689,7 +3694,6 @@ Non-gated items checked and ruled out: `Chat.isMessageAIGenerated`, `SummarizedM
 
 #### Unverified (kept as `likely`)
 
-- BC-046: whether the missing `LoadingIndicator` without `loadingMore` is intended. The code path is confirmed; the intent is not.
 - BC-041: the existing guide's `defaultMessageActionSet.filter(({ type }) => …)` snippet should fail with `TS2339`, because `QuickDropdownToggleActionSetItem` has no `type`. That conclusion comes from reading the type, not from compiling. The draft uses an `'type' in item` guard instead.
 - BC-045, BC-004 snippets: checked against V15 types by reading only; not compiled (the brief allows writing only this file, so no scratch compile was done).
 
@@ -3798,7 +3802,7 @@ Non-gated items checked and ruled out: `Chat.isMessageAIGenerated`, `SummarizedM
 - `Avatar`: `Icon` prop un-deprecated -> ruled-out. `Badge/MediaBadge` reads `attachment.custom.duration` -> ruled-out: LLC v10 attachment shape
 - `Button`, `Form`, `LoadMore`, `EmptyStateIndicator`, `Accessibility`, `Dialog`, `Loading`, `Notifications`: only i18n key moves (BC-067 / 09), `componentName` drops (BC-006), `useContextMenuContext` / `useDialogManager` throwing (BC-007). Otherwise ruled-out: `DialogAnchor fitAvailableSpace` now actually constrains size (was a no-op, opt-in prop), `NotificationList` uses idempotent `ensureNotificationTimeout`, `AttachmentUploadedSizeIndicator` reads `custom.file_size` (LLC shape).
 - `Tooltip`, `Portal`, `UtilityComponents`, `SafeAnchor`, `VisuallyHidden`, `SkipNavigation`: no source changes
-- `src/hooks`: new `useIsDmChannel`, `useMessagePaginator`, neither exported from the package root (see Notes); nothing removed
+- `src/hooks`: new `useIsDmChannel` (internal) and `useMessagePaginator` (exported from the package root since `fix/v15-dead-surface-cleanup`); nothing removed
 - `src/store`: `useStateStore` now types against `@stream-io/state-store` -> BC-001
 - `WithComponents`: merged value memoized on `[parentOverrides, overrides]`; `useComponentContextIcons` now accepts non-function components (`React.memo` / `forwardRef`) and re-reads when `icons` changes -> ruled-out: fixes, not breaks
 
@@ -3818,7 +3822,7 @@ Inaccuracies found in the existing guides while auditing. Fix them when the guid
   - "Attachment/poll availability" says the File action now disappears without `upload-file` permission when `customCdn` is unset; v14 already hid it.
   - "`AIStates` moves to `stream-chat`" says only the reactive `useAIState` honors `ai_indicator.stop`; v14 already handled it. Only the reset on connection loss is new.
   - "`ChatContext.channelsQueryState` -> removed" says `Channel` renders loading, error and `EmptyPlaceholder` states. It renders none of them.
-  - "`ChatContext.latestMessageDatesByChannels` -> removed" names `useIsCooldownActive`, which is not exported; only `useCooldownRemaining` is.
+  - "`ChatContext.latestMessageDatesByChannels` -> removed" names `useIsCooldownActive`, which was not exported; `fix/v15-dead-surface-cleanup` exports it, so the guide is now right.
   - "`ChannelListItem` `getLatestMessagePreview` prop -> removed" says the util was removed (it is still exported) and suggests overriding through `<Chat>` / `<Channel>` props that do not exist. Drop that mention; `ComponentProvider` (which it also names) works but replaces the parent context, so prefer `WithComponents`, which merges over it.
   - "`Thread` renders children" says `Thread` registers the thread with the `ThreadManager`; it does not. `ThreadHeaderProps` also keeps `StartContent` / `EndContent`, not only `overrideTitle`.
   - "`<Channel>` declares the channel active" still tells readers to reload on `connection.recovered`; the client reloads active channels itself since `3098a90a6`.
@@ -3827,6 +3831,6 @@ Inaccuracies found in the existing guides while auditing. Fix them when the guid
   - The `messageActions` snippet filters `defaultMessageActionSet` by `type`, but the dropdown-toggle item has no `type`; guard with `'type' in item`. The same section says passing `messageActions={['delete']}` "in v15 changed nothing"; it means v14.
 - `i18n-v15-migration.md` says the runtime "now lives in `stream-chat`" and that `stream-chat` depends on `i18next` / `dayjs`. The runtime is `@stream-io/i18n`, and `stream-chat@10` depends on neither. It also sends integrators to `@stream-io/i18n` directly for `addOrUpdateDayjsLocale()`. That export exists, but this package does not re-export it, and AGENTS.md says integrators should not import `@stream-io/i18n` directly; either re-export it or document the exception.
 - `i18n-v15-key-map.json` maps "Send message request failed" / "Edit message request failed" to `messageComposer.sendMessageFn...` / `messageComposer.updateMessageFn...`, which do not exist. The keys are `notification.messageSendFailed` / `notification.messageUpdateFailed`.
-- `AGENTS.md` (as contributor guidance) and the `GetStream/stream-chat-react#3237` description point to `useMessagePaginator()`, but it is not exported from `stream-chat-react` (`src/index.ts` does not re-export `src/hooks`). Integrators read `(thread ?? channel).messagePaginator` via `useThreadContext()` / `useChannel()`.
+- `AGENTS.md` (as contributor guidance) and the `GetStream/stream-chat-react#3237` description point to `useMessagePaginator()`. It was not exported from `stream-chat-react`; `fix/v15-dead-surface-cleanup` exports it from `src/index.ts`, so both are now right.
 - Group the guide by user task, as in the v14 guide: imports to change, props to remove, override keys to rename, behavior to re-wire (workspace navigation, channel initialization, request handlers).
-- The silent breaks deserve top billing because nothing fails to compile: selection and thread opening outside `ChatView` (BC-045 / BC-013 above), `Channel` no longer watching the channel, `MessageList.messages` being ignored, failed sends no longer restoring the composer, and required context hooks throwing.
+- The silent breaks deserve top billing because nothing fails to compile: selection and thread opening outside `ChatView` (BC-045 / BC-013 above), `Channel` no longer watching the channel, failed sends no longer restoring the composer, and required context hooks throwing.

From 8cc2de9e38092fc3207e350ad9a3b45770919e4c Mon Sep 17 00:00:00 2001
From: Oliver Lazoroski <oliver.lazoroski@gmail.com>
Date: Mon, 19 Oct 2026 13:43:57 +0200
Subject: [PATCH 4/5] docs(ChannelListItem): describe where the channel prop
 comes from in v15

---
 src/components/ChannelListItem/ChannelListItem.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/ChannelListItem/ChannelListItem.tsx b/src/components/ChannelListItem/ChannelListItem.tsx
index 9542058d34..7ac951bbe3 100644
--- a/src/components/ChannelListItem/ChannelListItem.tsx
+++ b/src/components/ChannelListItem/ChannelListItem.tsx
@@ -45,7 +45,7 @@ export type ChannelListItemUIProps = ChannelListItemProps & {
 };
 
 export type ChannelListItemProps = {
-  /** Comes from either the `channelRenderFilterFn` or `usePaginatedChannels` call from [ChannelList](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelList/ChannelList.tsx) */
+  /** The channel to preview: one of the items of the `ChannelPaginator` that [ChannelList](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelList/ChannelList.tsx) renders, or any channel when used on its own (e.g. in search results) */
   channel: Channel;
   /** If the component's channel is the active (selected) Channel */
   active?: boolean;

From 803467174a43ef0504de56f26a0adfddaf130e1e Mon Sep 17 00:00:00 2001
From: Oliver Lazoroski <oliver.lazoroski@gmail.com>
Date: Mon, 19 Oct 2026 13:44:00 +0200
Subject: [PATCH 5/5] fix!: remove dead v15 surface found by the API audit

Marks the removals in this branch as breaking for semantic-release.

BREAKING CHANGE: `MessageList` no longer accepts `messages`, `hasMore`,
`jumpToLatestMessage`, `loadingMoreNewer` or `messageLimit`, and
`VirtualizedMessageList` no longer accepts `messages`; the lists render and
paginate the message paginator. `CustomClasses.chatContainer` and the
`ComponentContext.LoadingErrorIndicator` slot are removed. Inside `ChatView`
the channel list no longer renders its own `str-chat <theme>` scope. See
ai-docs/v15-breaking-changes.md (BC-019, BC-046, BC-047, BC-073, BC-074).