Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🏎️ perf: Re-render Only the Tail Rows When a Message Is Sent (#16572)
Danny Avilab341f9380584
diff --git a/client/src/Providers/MessagesViewContext.tsx b/client/src/Providers/MessagesViewContext.tsxindex 1d9172c95b..afe54b5fe4 100644--- a/client/src/Providers/MessagesViewContext.tsx+++ b/client/src/Providers/MessagesViewContext.tsx@@ -24,11 +24,29 @@ interface MessagesViewContextValue {setMessages: ReturnType<typeof useChatContext>['setMessages'];}+type MessagesOperations = Pick<+ MessagesViewContextValue,+ 'ask' | 'regenerate' | 'handleContinue' | 'getMessages' | 'setMessages'+>;+const MessagesViewContext = createContext<MessagesViewContextValue | undefined>(undefined);-// Export the context so it can be provided by other providers (e.g., ShareMessagesProvider)-export { MessagesViewContext };-export type { MessagesViewContextValue };+/**+ * The view's operations alone. They are referentially stable, so components that+ * only call them (every message row's hover actions) are not re-rendered by the+ * submission and tail changes the combined context carries on each send.+ */+const MessagesOperationsContext = createContext<MessagesOperations | undefined>(undefined);++/**+ * Whether the view is generating, alone. A boolean context re-renders its consumers+ * only when a send starts or settles, which is when every row's rerun controls flip.+ */+const MessagesSubmittingContext = createContext(false);++// Export the contexts so they can be provided by other providers (e.g., ShareMessagesProvider)+export { MessagesViewContext, MessagesOperationsContext, MessagesSubmittingContext };+export type { MessagesViewContextValue, MessagesOperations };export function MessagesViewProvider({ children }: { children: React.ReactNode }) {const chatContext = useChatContext();@@ -101,10 +119,19 @@ export function MessagesViewProvider({ children }: { children: React.ReactNode });return (- <MessagesViewContext.Provider value={contextValue}>{children}</MessagesViewContext.Provider>+ <MessagesOperationsContext.Provider value={messageOperations}>+ <MessagesSubmittingContext.Provider value={isSubmitting}>+ <MessagesViewContext.Provider value={contextValue}>{children}</MessagesViewContext.Provider>+ </MessagesSubmittingContext.Provider>+ </MessagesOperationsContext.Provider>);}+/** Whether the view is generating; false outside a live messages view. */+export function useMessagesIsSubmitting(): boolean {+ return useContext(MessagesSubmittingContext);+}+export function useMessagesViewContext() {const context = useContext(MessagesViewContext);if (!context) {@@ -129,20 +156,15 @@ export function useMessagesSubmission() {}/** Hook for components that only need message operations */-export function useMessagesOperations() {- const { ask, regenerate, handleContinue, getMessages, setMessages } = useMessagesViewContext();- return useMemo(- () => ({ ask, regenerate, handleContinue, getMessages, setMessages }),- [ask, regenerate, handleContinue, getMessages, setMessages],- );+export function useMessagesOperations(): MessagesOperations {+ const context = useContext(MessagesOperationsContext);+ if (!context) {+ throw new Error('useMessagesOperations must be used within MessagesViewProvider');+ }+ return context;}-type OptionalMessagesOps = Pick<- MessagesViewContextValue,- 'ask' | 'regenerate' | 'handleContinue' | 'getMessages' | 'setMessages'->;--const NOOP_OPS: OptionalMessagesOps = {+const NOOP_OPS: MessagesOperations = {ask: () => {},regenerate: () => {},handleContinue: () => {},@@ -156,23 +178,8 @@ const NOOP_OPS: OptionalMessagesOps = {* be silently discarded rather than crashing. Callers must use optional chaining on* `getMessages()` results, as it returns `undefined` outside the provider.*/-export function useOptionalMessagesOperations(): OptionalMessagesOps {- const context = useContext(MessagesViewContext);- const ask = context?.ask;- const regenerate = context?.regenerate;- const handleContinue = context?.handleContinue;- const getMessages = context?.getMessages;- const setMessages = context?.setMessages;- return useMemo(- () => ({- ask: ask ?? NOOP_OPS.ask,- regenerate: regenerate ?? NOOP_OPS.regenerate,- handleContinue: handleContinue ?? NOOP_OPS.handleContinue,- getMessages: getMessages ?? NOOP_OPS.getMessages,- setMessages: setMessages ?? NOOP_OPS.setMessages,- }),- [ask, regenerate, handleContinue, getMessages, setMessages],- );+export function useOptionalMessagesOperations(): MessagesOperations {+ return useContext(MessagesOperationsContext) ?? NOOP_OPS;}/**diff --git a/client/src/common/types.ts b/client/src/common/types.tsindex 6d1ec5ce2a..15fefa73c5 100644--- a/client/src/common/types.ts+++ b/client/src/common/types.ts@@ -399,8 +399,11 @@ export type TMessageChatContext = {index: number;regenerate: (message: t.TMessage, options?: { addedConvo?: t.TConversation | null }) => void;conversation: t.TConversation | null;- latestMessageId: string | undefined;- latestMessageDepth: number | undefined;+ /** Getter backed by a ref, for reads at call time. Rendering reads the row's+ * `latestMessageId` prop, which its comparator gates on the row's relation. */+ readonly latestMessageId: string | undefined;+ /** Getter backed by a ref, for reads at call time (see `latestMessageId`). */+ readonly latestMessageDepth: number | undefined;handleContinue: (e: React.MouseEvent<HTMLButtonElement>) => void;/** Resolved once per chat from `interface.feedback`; false until the config loads */feedbackEnabled: boolean;diff --git a/client/src/components/Chat/Messages/Feedback.tsx b/client/src/components/Chat/Messages/Feedback.tsxindex af6b063797..5db87e64bf 100644--- a/client/src/components/Chat/Messages/Feedback.tsx+++ b/client/src/components/Chat/Messages/Feedback.tsx@@ -1,4 +1,4 @@-import React, { useState, useCallback, useMemo, useEffect } from 'react';+import React, { memo, useState, useCallback, useMemo, useEffect } from 'react';import * as Ariakit from '@ariakit/react';import { TFeedback, TFeedbackTag, getTagsForRating } from 'librechat-data-provider';import {@@ -222,11 +222,7 @@ function FeedbackButtons({const buttonClasses = (isActive: boolean, isLast: boolean) =>hoverButtonClasses({ isActive, isLast });-export default function Feedback({- isLast = false,- handleFeedback,- feedback: initialFeedback,-}: FeedbackProps) {+function Feedback({ isLast = false, handleFeedback, feedback: initialFeedback }: FeedbackProps) {const localize = useLocalize();const [openDialog, setOpenDialog] = useState(false);const [feedback, setFeedback] = useState<TFeedback | undefined>(initialFeedback);@@ -342,3 +338,6 @@ export default function Feedback({</>);}++/** Memoized: a send re-renders every row's toolbar, and nothing here depends on it. */+export default memo(Feedback);diff --git a/client/src/components/Chat/Messages/Fork.tsx b/client/src/components/Chat/Messages/Fork.tsxindex 341c7187fc..a5c4bebc4b 100644--- a/client/src/components/Chat/Messages/Fork.tsx+++ b/client/src/components/Chat/Messages/Fork.tsx@@ -1,4 +1,4 @@-import React, { useState, useRef } from 'react';+import React, { memo, useState, useRef } from 'react';import { useRecoilState } from 'recoil';import * as Ariakit from '@ariakit/react';import { VisuallyHidden } from '@ariakit/react';@@ -199,17 +199,18 @@ const CheckboxOption: React.FC<CheckboxOptionProps> = ({);};-export default function Fork({+function Fork({messageId,conversationId: _convoId,forkingSupported = false,- latestMessageId,+ getLatestMessageId,isLast = false,}: {messageId: string;conversationId: string | null;forkingSupported?: boolean;- latestMessageId?: string;+ /** Read when a fork starts: the split target must be the tail at click time. */+ getLatestMessageId?: () => string | undefined;isLast?: boolean;}) {const localize = useLocalize();@@ -277,7 +278,7 @@ export default function Fork({conversationId,option,splitAtTarget,- latestMessageId,+ latestMessageId: getLatestMessageId?.(),});};@@ -337,7 +338,7 @@ export default function Fork({splitAtTarget,conversationId,option: forkSetting,- latestMessageId,+ latestMessageId: getLatestMessageId?.(),});} else {popoverStore.toggle();@@ -440,3 +441,6 @@ export default function Fork({</>);}++/** Memoized: a send re-renders every row's toolbar, and nothing here depends on it. */+export default memo(Fork);diff --git a/client/src/components/Chat/Messages/HoverButtons.tsx b/client/src/components/Chat/Messages/HoverButtons.tsxindex 15c59e3438..0dc465de05 100644--- a/client/src/components/Chat/Messages/HoverButtons.tsx+++ b/client/src/components/Chat/Messages/HoverButtons.tsx@@ -12,8 +12,8 @@ import {RegenerateIcon,} from '@librechat/client';import type { TConversation, TMessage, TFeedback } from 'librechat-data-provider';+import { useMessagesIsSubmitting, useOptionalMessagesOperations } from '~/Providers';import { useGenerationsByLatest, useLocalize } from '~/hooks';-import { useOptionalMessagesOperations } from '~/Providers';import { hasEditablePart } from './Content/editableParts';import { revealedQueuedTurnFamily } from '~/store/steer';import { Fork } from '~/components/Conversations';@@ -29,11 +29,14 @@ type THoverButtons = {copyToClipboard: (setIsCopied: React.Dispatch<React.SetStateAction<boolean>>) => void;getCanCopy: () => boolean;conversation: TConversation | null;- isSubmitting: boolean;message: TMessage;regenerate: () => void;handleContinue: (e: React.MouseEvent<HTMLButtonElement>) => void;+ /** The tail as of the row's last render, which the row re-renders on whenever+ * this message enters or leaves it; compared against, never sent anywhere. */latestMessageId?: string;+ /** The tail at call time, for actions that send it (forking at a split target). */+ getLatestMessageId?: () => string | undefined;isLast: boolean;index: number;handleFeedback?: ({ feedback }: { feedback: TFeedback | undefined }) => void;@@ -129,15 +132,18 @@ const HoverButtons = ({copyToClipboard,getCanCopy,conversation,- isSubmitting,message,regenerate,handleContinue,latestMessageId,+ getLatestMessageId,isLast,handleFeedback,}: THoverButtons) => {const localize = useLocalize();+ /** Subscribed here rather than passed down: a send toggles the rerun controls on+ * every row, and only this toolbar has to re-render for it. */+ const isSubmitting = useMessagesIsSubmitting();const [isCopied, setIsCopied] = useState(false);const [TextToSpeech] = useRecoilState<boolean>(store.textToSpeech);const { getMessages } = useOptionalMessagesOperations();@@ -282,7 +288,7 @@ const HoverButtons = ({messageId={message.messageId}conversationId={conversation.conversationId}forkingSupported={forkingSupported}- latestMessageId={latestMessageId}+ getLatestMessageId={getLatestMessageId ?? (() => latestMessageId)}isLast={isLast}/>)}diff --git a/client/src/components/Chat/Messages/Message.tsx b/client/src/components/Chat/Messages/Message.tsxindex 4ab2e8f963..9accb6ba2a 100644--- a/client/src/components/Chat/Messages/Message.tsx+++ b/client/src/components/Chat/Messages/Message.tsx@@ -27,7 +27,8 @@ function Message(props: TMessageProps) {message: props.message,});const { message } = props;- const { chatContext, effectiveIsSubmitting } = useMemoizedChatContext(message, isSubmitting);+ const { chatContext, effectiveIsSubmitting, latestMessageId, latestMessageDepth } =+ useMemoizedChatContext(message, isSubmitting);if (!message || typeof message !== 'object') {return null;@@ -36,7 +37,13 @@ function Message(props: TMessageProps) {return (<MessageContainer handleScroll={handleScroll}><div className="m-auto justify-center px-4 py-3 sm:px-0">- <MessageRender {...props} isSubmitting={effectiveIsSubmitting} chatContext={chatContext} />+ <MessageRender+ {...props}+ chatContext={chatContext}+ isSubmitting={effectiveIsSubmitting}+ latestMessageId={latestMessageId}+ latestMessageDepth={latestMessageDepth}+ /></div></MessageContainer>);diff --git a/client/src/components/Chat/Messages/MessageParts.tsx b/client/src/components/Chat/Messages/MessageParts.tsxindex efd1f8bc35..01fcb3534a 100644--- a/client/src/components/Chat/Messages/MessageParts.tsx+++ b/client/src/components/Chat/Messages/MessageParts.tsx@@ -162,7 +162,6 @@ function MessageParts(props: TMessageProps) {isEditing={edit}message={message}enterEdit={enterEdit}- isSubmitting={isSubmitting}conversation={conversation ?? null}regenerate={() => regenerateMessage()}copyToClipboard={copyToClipboard}diff --git a/client/src/components/Chat/Messages/__tests__/Fork.spec.tsx b/client/src/components/Chat/Messages/__tests__/Fork.spec.tsxnew file mode 100644index 0000000000..8d59786b76--- /dev/null+++ b/client/src/components/Chat/Messages/__tests__/Fork.spec.tsx@@ -0,0 +1,61 @@+import React from 'react';+import { RecoilRoot } from 'recoil';+import { ForkOptions } from 'librechat-data-provider';+import { fireEvent, render, screen } from '@testing-library/react';+import store from '~/store';+import Fork from '../Fork';++const mockMutate = jest.fn();++jest.mock('~/data-provider', () => ({+ useForkConvoMutation: () => ({ mutate: mockMutate }),+}));++jest.mock('~/hooks', () => ({+ useLocalize: () => (key: string) => key,+ useNavigateToConvo: () => ({ navigateToConvo: jest.fn() }),+}));++jest.mock('@librechat/client', () => ({+ ...jest.requireActual('@librechat/client'),+ useToastContext: () => ({ showToast: jest.fn() }),+}));++describe('Fork', () => {+ beforeEach(() => {+ mockMutate.mockClear();+ });++ /** The row holding this button does not re-render when the tail moves, so the+ * split target is read when the fork starts rather than captured at render. */+ it('sends the tail current at click time as the split target', () => {+ let latestMessageId = 'assistant-2';+ render(+ <RecoilRoot+ initializeState={({ set }) => {+ set(store.rememberDefaultFork, true);+ set(store.forkSetting, ForkOptions.TARGET_LEVEL);+ set(store.splitAtTarget, true);+ }}+ >+ <Fork+ messageId="user-1"+ conversationId="convo-1"+ forkingSupported={true}+ getLatestMessageId={() => latestMessageId}+ />+ </RecoilRoot>,+ );++ latestMessageId = 'assistant-3';+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_fork_open_menu' }));++ expect(mockMutate).toHaveBeenCalledWith(+ expect.objectContaining({+ messageId: 'user-1',+ splitAtTarget: true,+ latestMessageId: 'assistant-3',+ }),+ );+ });+});diff --git a/client/src/components/Chat/Messages/__tests__/HoverButtons.spec.tsx b/client/src/components/Chat/Messages/__tests__/HoverButtons.spec.tsxindex 6ea8f3d11a..55cd394c0f 100644--- a/client/src/components/Chat/Messages/__tests__/HoverButtons.spec.tsx+++ b/client/src/components/Chat/Messages/__tests__/HoverButtons.spec.tsx@@ -1,7 +1,7 @@import React from 'react';import { MemoryRouter } from 'react-router-dom';-import { render, screen } from '@testing-library/react';import { RecoilRoot, type MutableSnapshot } from 'recoil';+import { act, render, screen } from '@testing-library/react';import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import {Constants,@@ -11,8 +11,9 @@ import {type TMessage,} from 'librechat-data-provider';import {- MessagesViewContext,- type MessagesViewContextValue,+ MessagesOperationsContext,+ MessagesSubmittingContext,+ type MessagesOperations,} from '~/Providers/MessagesViewContext';import { hasCopyableText } from '~/hooks/Messages/useCopyToClipboard';import HoverButtons from '~/components/Chat/Messages/HoverButtons';@@ -62,27 +63,28 @@ function renderHoverButtons({const { container } = render(<QueryClientProvider client={queryClient}><RecoilRoot initializeState={initializeState}>- <MessagesViewContext.Provider- value={{ getMessages: () => thread } as unknown as MessagesViewContextValue}+ <MessagesOperationsContext.Provider+ value={{ getMessages: () => thread } as unknown as MessagesOperations}>- <MemoryRouter>- <HoverButtons- index={0}- isLast={isLast}- isEditing={false}- message={message}- conversation={targetConversation}- isSubmitting={isSubmitting}- enterEdit={jest.fn()}- regenerate={jest.fn()}- handleContinue={jest.fn()}- copyToClipboard={jest.fn()}- getCanCopy={getCanCopy}- latestMessageId={latestMessageId}- handleFeedback={handleFeedback}- />- </MemoryRouter>- </MessagesViewContext.Provider>+ <MessagesSubmittingContext.Provider value={isSubmitting}>+ <MemoryRouter>+ <HoverButtons+ index={0}+ isLast={isLast}+ isEditing={false}+ message={message}+ conversation={targetConversation}+ enterEdit={jest.fn()}+ regenerate={jest.fn()}+ handleContinue={jest.fn()}+ copyToClipboard={jest.fn()}+ getCanCopy={getCanCopy}+ latestMessageId={latestMessageId}+ handleFeedback={handleFeedback}+ />+ </MemoryRouter>+ </MessagesSubmittingContext.Provider>+ </MessagesOperationsContext.Provider></RecoilRoot></QueryClientProvider>,);@@ -533,6 +535,76 @@ describe('HoverButtons edit affordance', () => {});});+/**+ * The row above these controls no longer re-renders when a send starts or settles,+ * so the rerun gate has to follow the pane's submission state on its own.+ */+describe('HoverButtons submission state', () => {+ const assistantMessage = {+ ...userMessage,+ messageId: 'assistant-earlier',+ parentMessageId: userMessage.messageId,+ isCreatedByUser: false,+ text: 'An earlier answer',+ } as TMessage;++ let setSubmitting: (value: boolean) => void = () => undefined;+ /** Holds the pane's submission state; the toolbar element itself never changes. */+ function SubmittingHost({ children }: { children: React.ReactNode }) {+ const [submitting, setState] = React.useState(false);+ setSubmitting = setState;+ return (+ <MessagesSubmittingContext.Provider value={submitting}>+ {children}+ </MessagesSubmittingContext.Provider>+ );+ }++ it('withholds and restores rerun on a settled row as a send starts and ends', () => {+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });+ const buttons = (+ <HoverButtons+ index={0}+ isLast={true}+ isEditing={false}+ message={assistantMessage}+ conversation={conversation}+ enterEdit={jest.fn()}+ regenerate={jest.fn()}+ handleContinue={jest.fn()}+ copyToClipboard={jest.fn()}+ getCanCopy={() => true}+ latestMessageId="assistant-latest"+ />+ );+ render(+ <QueryClientProvider client={queryClient}>+ <RecoilRoot initializeState={({ set }) => set(store.textToSpeech, false)}>+ <MessagesOperationsContext.Provider+ value={+ {+ getMessages: () => [userMessage, assistantMessage],+ } as unknown as MessagesOperations+ }+ >+ <MemoryRouter>+ <SubmittingHost>{buttons}</SubmittingHost>+ </MemoryRouter>+ </MessagesOperationsContext.Provider>+ </RecoilRoot>+ </QueryClientProvider>,+ );++ expect(screen.getByTestId('regenerate-generation-button')).toBeInTheDocument();++ act(() => setSubmitting(true));+ expect(screen.queryByTestId('regenerate-generation-button')).toBeNull();++ act(() => setSubmitting(false));+ expect(screen.getByTestId('regenerate-generation-button')).toBeInTheDocument();+ });+});+describe('HoverButtons feedback affordance', () => {const assistantMessage = {...userMessage,diff --git a/client/src/components/Chat/Messages/ui/MessageRender.tsx b/client/src/components/Chat/Messages/ui/MessageRender.tsxindex 37a3a9f8d0..35f98a2a5b 100644--- a/client/src/components/Chat/Messages/ui/MessageRender.tsx+++ b/client/src/components/Chat/Messages/ui/MessageRender.tsx@@ -3,10 +3,11 @@ import { useRecoilValue } from 'recoil';import type { TMessage } from 'librechat-data-provider';import type { TMessageProps, TMessageIcon, TMessageChatContext } from '~/common';import {- areMessageFieldsEqual,cn,- getHeaderPrefixForScreenReader,+ isSameTailRelation,getMessageAriaLabel,+ areMessageFieldsEqual,+ getHeaderPrefixForScreenReader,} from '~/utils';import { revealOnRowHoverClasses, messageFooterClasses } from '~/components/Chat/Messages/styles';import { parseWakeupText } from '~/components/Chat/Messages/Content/Parts/wakeup';@@ -33,6 +34,9 @@ type MessageRenderProps = {isSubmitting?: boolean;/** Stable context object from wrapper — avoids ChatContext subscription inside memo */chatContext: TMessageChatContext;+ /** The thread's tail; the comparator re-renders only when this row's relation to it changes */+ latestMessageId?: string;+ latestMessageDepth?: number;} & Pick<TMessageProps,'currentEditId' | 'setCurrentEditId' | 'siblingIdx' | 'setSiblingIdx' | 'siblingCount'@@ -66,7 +70,7 @@ function areMessageRenderPropsEqual(prev: MessageRenderProps, next: MessageRendereturn false;}- return areMessageFieldsEqual(prev.message, next.message);+ return areMessageFieldsEqual(prev.message, next.message) && isSameTailRelation(prev, next);}const MessageRender = memo(function MessageRender({@@ -78,6 +82,8 @@ const MessageRender = memo(function MessageRender({setCurrentEditId,isSubmitting = false,chatContext,+ latestMessageId,+ latestMessageDepth,}: MessageRenderProps) {const localize = useLocalize();const {@@ -91,11 +97,9 @@ const MessageRender = memo(function MessageRender({messageLabel,handleFeedback,handleContinue,- latestMessageId,copyToClipboard,getCanCopy,regenerateMessage,- latestMessageDepth,hasConfiguredSender,} = useMessageActions({message: msg,@@ -106,6 +110,7 @@ const MessageRender = memo(function MessageRender({const maximizeChatSpace = useRecoilValue(store.maximizeChatSpace);const handleRegenerateMessage = useCallback(() => regenerateMessage(), [regenerateMessage]);+ const getLatestMessageId = useCallback(() => chatContext.latestMessageId, [chatContext]);const hasNoChildren = !(msg?.children?.length ?? 0);const isLast = useMemo(() => hasNoChildren && (msg?.depth === latestMessageDepth || msg?.depth === -1),@@ -206,13 +211,13 @@ const MessageRender = memo(function MessageRender({isEditing={edit}message={msg}enterEdit={enterEdit}- isSubmitting={chatContext.isSubmitting}conversation={conversation ?? null}regenerate={handleRegenerateMessage}copyToClipboard={copyToClipboard}getCanCopy={getCanCopy}handleContinue={handleContinue}latestMessageId={latestMessageId}+ getLatestMessageId={getLatestMessageId}handleFeedback={handleFeedback}isLast={isLast}/>diff --git a/client/src/components/Messages/ContentRender.tsx b/client/src/components/Messages/ContentRender.tsxindex 8207d59440..e02312457a 100644--- a/client/src/components/Messages/ContentRender.tsx+++ b/client/src/components/Messages/ContentRender.tsx@@ -5,10 +5,11 @@ import { Constants } from 'librechat-data-provider';import type { TMessage, TMessageContentParts } from 'librechat-data-provider';import type { TMessageProps, TMessageIcon, TMessageChatContext } from '~/common';import {- areMessageFieldsEqual,cn,- getHeaderPrefixForScreenReader,+ isSameTailRelation,getMessageAriaLabel,+ areMessageFieldsEqual,+ getHeaderPrefixForScreenReader,} from '~/utils';import { revealOnRowHoverClasses, messageFooterClasses } from '~/components/Chat/Messages/styles';import { useLocalize, useAttachments, useMessageActions, useContentMetadata } from '~/hooks';@@ -43,6 +44,9 @@ type ContentRenderProps = {isSubmitting?: boolean;/** Stable context object from wrapper — avoids ChatContext subscription inside memo */chatContext: TMessageChatContext;+ /** The thread's tail; the comparator re-renders only when this row's relation to it changes */+ latestMessageId?: string;+ latestMessageDepth?: number;} & Pick<TMessageProps,'currentEditId' | 'setCurrentEditId' | 'siblingIdx' | 'setSiblingIdx' | 'siblingCount'@@ -75,7 +79,7 @@ function areContentRenderPropsEqual(prev: ContentRenderProps, next: ContentRendereturn false;}- return areMessageFieldsEqual(prev.message, next.message);+ return areMessageFieldsEqual(prev.message, next.message) && isSameTailRelation(prev, next);}const ContentRender = memo(function ContentRender({@@ -87,6 +91,8 @@ const ContentRender = memo(function ContentRender({setCurrentEditId,isSubmitting = false,chatContext,+ latestMessageId,+ latestMessageDepth,}: ContentRenderProps) {const localize = useLocalize();const { attachments, searchResults } = useAttachments({@@ -103,11 +109,9 @@ const ContentRender = memo(function ContentRender({messageLabel,handleContinue,handleFeedback,- latestMessageId,copyToClipboard,getCanCopy,regenerateMessage,- latestMessageDepth,hasConfiguredSender,} = useMessageActions({message: msg,@@ -121,6 +125,7 @@ const ContentRender = memo(function ContentRender({const showThinking = useAtomValue(showThinkingAtom);const handleRegenerateMessage = useCallback(() => regenerateMessage(), [regenerateMessage]);+ const getLatestMessageId = useCallback(() => chatContext.latestMessageId, [chatContext]);const isLast = useMemo(() => !(msg?.children?.length ?? 0) && (msg?.depth === latestMessageDepth || msg?.depth === -1),[msg?.children, msg?.depth, latestMessageDepth],@@ -206,13 +211,13 @@ const ContentRender = memo(function ContentRender({message={msg}isEditing={edit}enterEdit={enterEdit}- isSubmitting={chatContext.isSubmitting}conversation={conversation ?? null}regenerate={handleRegenerateMessage}copyToClipboard={copyToClipboard}getCanCopy={getCanCopy}handleContinue={handleContinue}latestMessageId={latestMessageId}+ getLatestMessageId={getLatestMessageId}handleFeedback={handleFeedback}isLast={isLast}/>diff --git a/client/src/components/Messages/MessageContent.tsx b/client/src/components/Messages/MessageContent.tsxindex 4c1b5d5e05..cdb0a5b889 100644--- a/client/src/components/Messages/MessageContent.tsx+++ b/client/src/components/Messages/MessageContent.tsx@@ -27,7 +27,8 @@ function MessageContent(props: TMessageProps) {message: props.message,});const { message } = props;- const { chatContext, effectiveIsSubmitting } = useMemoizedChatContext(message, isSubmitting);+ const { chatContext, effectiveIsSubmitting, latestMessageId, latestMessageDepth } =+ useMemoizedChatContext(message, isSubmitting);if (!message || typeof message !== 'object') {return null;@@ -36,7 +37,13 @@ function MessageContent(props: TMessageProps) {return (<MessageContainer handleScroll={handleScroll}><div className="m-auto justify-center px-4 py-3 sm:px-0">- <ContentRender {...props} isSubmitting={effectiveIsSubmitting} chatContext={chatContext} />+ <ContentRender+ {...props}+ chatContext={chatContext}+ isSubmitting={effectiveIsSubmitting}+ latestMessageId={latestMessageId}+ latestMessageDepth={latestMessageDepth}+ /></div></MessageContainer>);diff --git a/client/src/components/Messages/__tests__/ContentRender.tail.spec.tsx b/client/src/components/Messages/__tests__/ContentRender.tail.spec.tsxnew file mode 100644index 0000000000..dcf006b7ed--- /dev/null+++ b/client/src/components/Messages/__tests__/ContentRender.tail.spec.tsx@@ -0,0 +1,240 @@+import React, { useMemo, useState } from 'react';+import { RecoilRoot } from 'recoil';+import { act, render } from '@testing-library/react';+import type { TConversation, TMessage } from 'librechat-data-provider';+import { ChatContext, MessagesViewProvider, useChatContext } from '~/Providers';+import MessageContent from '../MessageContent';++const mockRowRenders = new Map<string, number>();++jest.mock('~/components/Chat/Messages/ui/MessageRow', () => ({+ __esModule: true,+ default: ({+ id,+ children,+ footer,+ }: {+ id?: string;+ children: React.ReactNode;+ footer: React.ReactNode;+ }) => {+ mockRowRenders.set(id ?? '', (mockRowRenders.get(id ?? '') ?? 0) + 1);+ return (+ <div data-testid={`row-${id}`}>+ {children}+ {footer}+ </div>+ );+ },+}));++jest.mock('~/components/Chat/Messages/Content/ContentParts', () => ({+ __esModule: true,+ default: () => null,+}));++jest.mock('~/components/Chat/Messages/HoverButtons', () => ({+ __esModule: true,+ default: () => null,+}));++jest.mock('~/components/Chat/Messages/MessageIcon', () => ({+ __esModule: true,+ default: () => null,+}));++jest.mock('~/components/Chat/Messages/Elapsed', () => ({+ __esModule: true,+ default: () => null,+ shouldShowElapsed: () => false,+}));++jest.mock('~/hooks', () => ({+ useMessageProcess: jest.requireActual('~/hooks/Messages/useMessageProcess').default,+ useMemoizedChatContext: jest.requireActual('~/hooks/Messages/useMemoizedChatContext').default,+ useLocalize: () => (key: string) => key,+ useAttachments: () => ({ attachments: undefined, searchResults: undefined }),+ useContentMetadata: () => ({ hasParallelContent: false }),+ useMessageActions: ({ chatContext }: { chatContext: { conversation: TConversation } }) => ({+ edit: false,+ index: 0,+ agent: undefined,+ assistant: undefined,+ conversation: chatContext.conversation,+ messageLabel: 'Assistant',+ enterEdit: mockNoop,+ handleContinue: mockNoop,+ handleFeedback: undefined,+ copyToClipboard: mockNoop,+ getCanCopy: () => true,+ regenerateMessage: mockNoop,+ hasConfiguredSender: false,+ }),+}));++function mockNoop() {}++const conversation = {+ conversationId: 'convo-tail',+ endpoint: 'openAI',+ model: 'gpt-4',+} as TConversation;++function row(messageId: string, parentMessageId: string, depth: number, isCreatedByUser: boolean) {+ return {+ messageId,+ parentMessageId,+ depth,+ isCreatedByUser,+ conversationId: conversation.conversationId,+ sender: isCreatedByUser ? 'User' : 'Assistant',+ text: messageId,+ content: [{ type: 'text', text: messageId }],+ createdAt: '2026-09-30T12:00:00.000Z',+ children: [],+ } as unknown as TMessage;+}++/** Links each row to the next, as the thread index does for the visible path. */+function thread(rows: TMessage[]): TMessage[] {+ return rows.map((message, index) => ({+ ...message,+ children: rows[index + 1] ? [rows[index + 1]] : [],+ }));+}++const settled = [+ row('user-1', '00000000-0000-0000-0000-000000000000', 0, true),+ row('assistant-1', 'user-1', 1, false),+ row('user-2', 'assistant-1', 2, true),+ row('assistant-2', 'user-2', 3, false),+];++type ThreadState = {+ messages: TMessage[];+ latestMessageId: string;+ isSubmitting: boolean;+};++let setThreadState: React.Dispatch<React.SetStateAction<ThreadState>> = () => undefined;+const setCurrentEditId = () => undefined;+const setSiblingIdx = () => undefined;+const stableHelpers = {+ ask: jest.fn(),+ regenerate: jest.fn(),+ handleContinue: jest.fn(),+ setAbortScroll: jest.fn(),+ getMessages: jest.fn(),+ setMessages: jest.fn(),+};++function Thread() {+ const [state, setState] = useState<ThreadState>({+ messages: thread(settled),+ latestMessageId: 'assistant-2',+ isSubmitting: false,+ });+ setThreadState = setState;+ const latestMessageDepth = state.messages.find(+ (message) => message.messageId === state.latestMessageId,+ )?.depth;++ const chatHelpers = useMemo(+ () =>+ ({+ ...stableHelpers,+ index: 0,+ conversation,+ abortScroll: false,+ feedbackEnabled: true,+ isSubmitting: state.isSubmitting,+ latestMessageId: state.latestMessageId,+ latestMessageDepth,+ }) as unknown as ReturnType<typeof useChatContext>,+ [state.isSubmitting, state.latestMessageId, latestMessageDepth],+ );++ return (+ <ChatContext.Provider value={chatHelpers}>+ <MessagesViewProvider>+ {state.messages.map((message) => (+ <MessageContent+ key={message.depth}+ message={message}+ currentEditId={null}+ setCurrentEditId={setCurrentEditId}+ siblingIdx={0}+ siblingCount={1}+ setSiblingIdx={setSiblingIdx}+ />+ ))}+ </MessagesViewProvider>+ </ChatContext.Provider>+ );+}++function rendersOf(...ids: string[]) {+ return ids.map((id) => mockRowRenders.get(id) ?? 0);+}++describe('message rows across a send', () => {+ beforeEach(() => {+ mockRowRenders.clear();+ render(+ <RecoilRoot>+ <Thread />+ </RecoilRoot>,+ );+ mockRowRenders.clear();+ });++ it('re-renders only the rows entering or leaving the tail when a message is sent', () => {+ act(() => {+ setThreadState(() => ({+ messages: thread([+ ...settled,+ row('user-3', 'assistant-2', 4, true),+ row('assistant-3_', 'user-3', 5, false),+ ]),+ latestMessageId: 'assistant-3_',+ isSubmitting: true,+ }));+ });++ expect(rendersOf('user-1', 'assistant-1', 'user-2')).toEqual([0, 0, 0]);+ expect(rendersOf('assistant-2', 'user-3', 'assistant-3_')).toEqual([1, 1, 1]);+ });++ it('leaves settled rows alone when the streaming id hydrates and the run settles', () => {+ const sent = [+ ...settled,+ row('user-3', 'assistant-2', 4, true),+ row('assistant-3_', 'user-3', 5, false),+ ];+ act(() => {+ setThreadState({+ messages: thread(sent),+ latestMessageId: 'assistant-3_',+ isSubmitting: true,+ });+ });+ mockRowRenders.clear();++ const hydrated = [...sent.slice(0, 5), row('assistant-3', 'user-3', 5, false)];+ act(() => {+ setThreadState({+ messages: thread(hydrated),+ latestMessageId: 'assistant-3',+ isSubmitting: true,+ });+ });+ act(() => {+ setThreadState((current) => ({ ...current, isSubmitting: false }));+ });++ expect(rendersOf('user-1', 'assistant-1', 'user-2', 'assistant-2', 'user-3')).toEqual([+ 0, 0, 0, 0, 0,+ ]);+ expect(mockRowRenders.get('assistant-3')).toBeGreaterThan(0);+ });+});diff --git a/client/src/components/Share/ShareMessagesProvider.tsx b/client/src/components/Share/ShareMessagesProvider.tsxindex cfaeff338c..7a958a6f59 100644--- a/client/src/components/Share/ShareMessagesProvider.tsx+++ b/client/src/components/Share/ShareMessagesProvider.tsx@@ -1,7 +1,7 @@import React, { useMemo } from 'react';import type { TMessage } from 'librechat-data-provider';-import type { MessagesViewContextValue } from '~/Providers/MessagesViewContext';-import { MessagesViewContext } from '~/Providers/MessagesViewContext';+import type { MessagesViewContextValue, MessagesOperations } from '~/Providers/MessagesViewContext';+import { MessagesViewContext, MessagesOperationsContext } from '~/Providers/MessagesViewContext';interface ShareMessagesProviderProps {messages: TMessage[];@@ -37,7 +37,20 @@ export function ShareMessagesProvider({ messages, children }: ShareMessagesProvi[messages],);+ const operations = useMemo<MessagesOperations>(+ () => ({+ ask: contextValue.ask,+ regenerate: contextValue.regenerate,+ handleContinue: contextValue.handleContinue,+ getMessages: contextValue.getMessages,+ setMessages: contextValue.setMessages,+ }),+ [contextValue],+ );+return (- <MessagesViewContext.Provider value={contextValue}>{children}</MessagesViewContext.Provider>+ <MessagesOperationsContext.Provider value={operations}>+ <MessagesViewContext.Provider value={contextValue}>{children}</MessagesViewContext.Provider>+ </MessagesOperationsContext.Provider>);}diff --git a/client/src/hooks/Chat/useChatHelpers.ts b/client/src/hooks/Chat/useChatHelpers.tsindex 46eb08bc29..450a79b189 100644--- a/client/src/hooks/Chat/useChatHelpers.ts+++ b/client/src/hooks/Chat/useChatHelpers.ts@@ -109,6 +109,10 @@ export default function useChatHelpers(index = 0, paramId?: string) {const setSiblingIdx = useSetAtom(siblingIdxFamily(siblingKey(latestMessage?.parentMessageId ?? null)),);+ /** The setter is rebound whenever the tail's parent changes (every turn); the+ * ref keeps `handleContinue` referentially stable so rows do not re-render. */+ const setSiblingIdxRef = useRef(setSiblingIdx);+ setSiblingIdxRef.current = setSiblingIdx;const setMessages = useCallback((messages: TMessage[]) => {@@ -374,9 +378,9 @@ export default function useChatHelpers(index = 0, paramId?: string) {(e: React.MouseEvent<HTMLButtonElement>) => {e.preventDefault();continueGeneration();- setSiblingIdx(0);+ setSiblingIdxRef.current(0);},- [continueGeneration, setSiblingIdx],+ [continueGeneration],);const [preset, setPreset] = useRecoilState(store.presetByIndex(index));diff --git a/client/src/hooks/Messages/__tests__/useMemoizedChatContext.spec.tsx b/client/src/hooks/Messages/__tests__/useMemoizedChatContext.spec.tsxindex 75b91929d5..50d410db5c 100644--- a/client/src/hooks/Messages/__tests__/useMemoizedChatContext.spec.tsx+++ b/client/src/hooks/Messages/__tests__/useMemoizedChatContext.spec.tsx@@ -1,7 +1,7 @@import { renderHook } from '@testing-library/react';import type { TConversation, TMessage } from 'librechat-data-provider';-import { useChatContext } from '~/Providers';import useMemoizedChatContext from '../useMemoizedChatContext';+import { useChatContext } from '~/Providers';jest.mock('~/Providers', () => ({useChatContext: jest.fn(),@@ -27,15 +27,19 @@ const message = (overrides: Partial<TMessage> = {}) =>...overrides,}) as TMessage;-function mockChatContext(latestMessageId: string | undefined) {+const stableHelpers = {+ ask: jest.fn(),+ regenerate: jest.fn(),+ handleContinue: jest.fn(),+};++function mockChatContext(latestMessageId: string | undefined, latestMessageDepth = -1) {mockUseChatContext.mockReturnValue({- ask: jest.fn(),+ ...stableHelpers,index: 0,- regenerate: jest.fn(),conversation,latestMessageId,- latestMessageDepth: -1,- handleContinue: jest.fn(),+ latestMessageDepth,isSubmitting: true,} as unknown as ReturnType<typeof useChatContext>);}@@ -61,4 +65,40 @@ describe('useMemoizedChatContext', () => {expect(result.current.effectiveIsSubmitting).toBe(false);expect(result.current.chatContext.isSubmitting).toBe(true);});++ /** Each send and each server id hydration moves the tail. A context object keyed+ * on it re-rendered every memoized row in the thread; rows now read the tail+ * from props their comparator gates, and the object keeps its identity. */+ it('keeps the context object stable while the tail and submission state move', () => {+ mockChatContext('assistant-2', 3);+ const row = message({ messageId: 'assistant-1', depth: 1 });+ const { result, rerender } = renderHook(+ ({ submitting }: { submitting: boolean }) => useMemoizedChatContext(row, submitting),+ { initialProps: { submitting: false } },+ );+ const initial = result.current.chatContext;++ mockChatContext('assistant-3_', 5);+ rerender({ submitting: true });++ expect(result.current.chatContext).toBe(initial);+ expect(result.current.latestMessageId).toBe('assistant-3_');+ expect(result.current.latestMessageDepth).toBe(5);+ });++ it('reads the current tail and submission state through the stable object', () => {+ mockChatContext('assistant-2', 3);+ const { result, rerender } = renderHook(+ ({ submitting }: { submitting: boolean }) => useMemoizedChatContext(message(), submitting),+ { initialProps: { submitting: false } },+ );+ const { chatContext } = result.current;++ mockChatContext('assistant-3', 5);+ rerender({ submitting: true });++ expect(chatContext.latestMessageId).toBe('assistant-3');+ expect(chatContext.latestMessageDepth).toBe(5);+ expect(chatContext.isSubmitting).toBe(true);+ });});diff --git a/client/src/hooks/Messages/useMemoizedChatContext.ts b/client/src/hooks/Messages/useMemoizedChatContext.tsindex 94430e37ae..6bff196fa9 100644--- a/client/src/hooks/Messages/useMemoizedChatContext.ts+++ b/client/src/hooks/Messages/useMemoizedChatContext.ts@@ -3,24 +3,39 @@ import type { TMessage } from 'librechat-data-provider';import type { TMessageChatContext } from '~/common/types';import { useChatContext } from '~/Providers';+type LiveChatValues = {+ isSubmitting: boolean;+ latestMessageId: string | undefined;+ latestMessageDepth: number | undefined;+};+/*** Creates a stable `TMessageChatContext` object for memo'd message components.** Subscribes to `useChatContext()` internally (intended to be called from non-memo'd* wrapper components like `Message` and `MessageContent`), then produces:- * - A `chatContext` object that stays referentially stable during streaming- * (uses a getter for `isSubmitting` backed by a ref)+ * - A `chatContext` object that stays referentially stable across submissions and+ * new turns: `isSubmitting`, `latestMessageId` and `latestMessageDepth` are+ * getters backed by a ref, for reads at call time (click handlers)* - A stable `conversation` reference that only updates when rendering-relevant fields change* - An `effectiveIsSubmitting` value (false for non-latest messages)+ * - The current `latestMessageId` / `latestMessageDepth`, which the wrapper passes+ * to the row as props so the row's comparator can ignore changes that leave+ * this row's relation to the tail unchanged (see `isSameTailRelation`)+ *+ * Every submission and every server id hydration moves the tail, so keying the+ * context object on those values re-rendered every row of the thread several+ * times per send, when only the rows entering or leaving the tail change.*/export default function useMemoizedChatContext(message: TMessage | null | undefined,isSubmitting: boolean,) {const chatCtx = useChatContext();+ const { latestMessageId, latestMessageDepth } = chatCtx;- const isSubmittingRef = useRef(isSubmitting);- isSubmittingRef.current = isSubmitting;+ const liveRef = useRef<LiveChatValues>({ isSubmitting, latestMessageId, latestMessageDepth });+ liveRef.current = { isSubmitting, latestMessageId, latestMessageDepth };/*** Stabilize conversation: only update when rendering-relevant fields change,@@ -39,44 +54,37 @@ export default function useMemoizedChatContext(],);- /**- * `isSubmitting` is included in deps so that chatContext gets a new reference- * when streaming starts/ends (2x per session). This ensures HoverButtons- * re-renders to update regenerate/edit button visibility via useGenerationsByLatest.- * The getter pattern is still valuable: callbacks reading chatContext.isSubmitting- * at call-time always get the current value even between these re-renders.- */const chatContext: TMessageChatContext = useMemo(() => ({ask: chatCtx.ask,index: chatCtx.index,regenerate: chatCtx.regenerate,conversation: stableConversation,- latestMessageId: chatCtx.latestMessageId,- latestMessageDepth: chatCtx.latestMessageDepth,handleContinue: chatCtx.handleContinue,feedbackEnabled: chatCtx.feedbackEnabled,get isSubmitting() {- return isSubmittingRef.current;+ return liveRef.current.isSubmitting;+ },+ get latestMessageId() {+ return liveRef.current.latestMessageId;+ },+ get latestMessageDepth() {+ return liveRef.current.latestMessageDepth;},}),- // eslint-disable-next-line react-hooks/exhaustive-deps[chatCtx.ask,chatCtx.index,chatCtx.regenerate,stableConversation,- chatCtx.latestMessageId,- chatCtx.latestMessageDepth,chatCtx.handleContinue,chatCtx.feedbackEnabled,- isSubmitting, // intentional: forces new reference on streaming start/end so HoverButtons re-renders],);const messageId = message?.messageId ?? null;- const isLatestMessage = messageId === chatCtx.latestMessageId;+ const isLatestMessage = messageId === latestMessageId;const effectiveIsSubmitting = isLatestMessage ? isSubmitting : false;- return { chatContext, effectiveIsSubmitting };+ return { chatContext, effectiveIsSubmitting, latestMessageId, latestMessageDepth };}diff --git a/client/src/hooks/Messages/useMessageActions.tsx b/client/src/hooks/Messages/useMessageActions.tsxindex 6f5a56b5b7..9ac1f616d8 100644--- a/client/src/hooks/Messages/useMessageActions.tsx+++ b/client/src/hooks/Messages/useMessageActions.tsx@@ -45,13 +45,11 @@ export default function useMessageActions(props: TMessageActions) {index,regenerate,conversation,- latestMessageId,- latestMessageDepth,handleContinue,feedbackEnabled,- // NOTE: isSubmitting is intentionally NOT destructured here.- // chatContext.isSubmitting is a getter backed by a ref — destructuring- // would capture a one-time snapshot. Always access via chatContext.isSubmitting.+ // NOTE: isSubmitting, latestMessageId and latestMessageDepth are intentionally+ // NOT destructured here. They are getters backed by a ref — destructuring+ // would capture a one-time snapshot. Rows render them from their own props.} = chatContext;const getAddedConvo = useGetAddedConvo();@@ -205,8 +203,6 @@ export default function useMessageActions(props: TMessageActions) {handleFeedback: feedbackEnabled ? handleFeedback : undefined,handleContinue,copyToClipboard,- latestMessageId,regenerateMessage,- latestMessageDepth,};}diff --git a/client/src/utils/__tests__/messages.test.ts b/client/src/utils/__tests__/messages.test.tsindex 492d942e33..5f42bd0cc7 100644--- a/client/src/utils/__tests__/messages.test.ts+++ b/client/src/utils/__tests__/messages.test.ts@@ -13,6 +13,7 @@ import {getHeaderPrefixForScreenReader,areMessageFieldsEqual,areMessageRowPropsEqual,+ isSameTailRelation,isSubmittableMessage,createDualMessageContent,} from '../messages';@@ -287,6 +288,55 @@ describe('getMessageTimestamp', () => {expect(() => getMessageTimestamp(iso, 'not a locale!!')).not.toThrow();expect(getMessageTimestamp(iso, 'not a locale!!')).not.toBeNull();});++ /** Every message row formats its timestamp on each render; constructing the+ * Intl formatters per call made them the costliest function of a send. */+ it('reuses its formatters across calls for the same locale and clock', () => {+ const { DateTimeFormat, RelativeTimeFormat } = Intl;+ const replaceIntl = (key: 'DateTimeFormat' | 'RelativeTimeFormat', value: unknown) =>+ Object.defineProperty(Intl, key, { value, configurable: true, writable: true });+ const constructed = { absolute: 0, relative: 0 };+ replaceIntl(+ 'DateTimeFormat',+ class extends DateTimeFormat {+ constructor(...args: ConstructorParameters<typeof DateTimeFormat>) {+ super(...args);+ constructed.absolute += 1;+ }+ },+ );+ replaceIntl(+ 'RelativeTimeFormat',+ class extends RelativeTimeFormat {+ constructor(...args: ConstructorParameters<typeof RelativeTimeFormat>) {+ super(...args);+ constructed.relative += 1;+ }+ },+ );+ try {+ const iso = new Date(NOW - 5 * 60 * 1000).toISOString();+ const first = getMessageTimestamp(iso, 'fr-CA', true);+ const second = getMessageTimestamp(iso, 'fr-CA', true);+ getMessageTimestamp(iso, 'fr-CA', true);++ expect(second).toEqual(first);+ expect(constructed).toEqual({ absolute: 1, relative: 1 });++ getMessageTimestamp(iso, 'fr-CA', false);+ expect(constructed).toEqual({ absolute: 2, relative: 1 });+ } finally {+ replaceIntl('DateTimeFormat', DateTimeFormat);+ replaceIntl('RelativeTimeFormat', RelativeTimeFormat);+ }+ });++ it('keeps a formatter per clock format', () => {+ const iso = new Date(2026, 5, 12, 15, 5).toISOString();++ expect(getMessageTimestamp(iso, 'en-US', true)?.absolute).toMatch(/3:05\sPM/);+ expect(getMessageTimestamp(iso, 'en-US', false)?.absolute).toMatch(/15:05/);+ });});const noop = () => {};@@ -411,6 +461,42 @@ describe('areMessageRowPropsEqual', () => {});});+describe('isSameTailRelation', () => {+ const tailProps = (+ messageId: string,+ depth: number,+ latestMessageId: string | undefined,+ latestMessageDepth: number | undefined,+ ) => ({+ message: makeMessage({ messageId, depth }),+ latestMessageId,+ latestMessageDepth,+ });++ it('ignores a tail move that neither reaches nor leaves the row', () => {+ expect(isSameTailRelation(tailProps('a', 1, 'b', 3), tailProps('a', 1, 'c_', 5))).toBe(true);+ expect(isSameTailRelation(tailProps('a', 1, 'c_', 5), tailProps('a', 1, 'c', 5))).toBe(true);+ });++ it('re-renders the row the tail leaves', () => {+ expect(isSameTailRelation(tailProps('b', 3, 'b', 3), tailProps('b', 3, 'c_', 5))).toBe(false);+ });++ it('re-renders the row the tail reaches', () => {+ expect(isSameTailRelation(tailProps('c', 5, 'c_', 5), tailProps('c', 5, 'c', 5))).toBe(false);+ });++ it('re-renders when the tail depth reaches or leaves the row depth', () => {+ expect(isSameTailRelation(tailProps('x', 3, 'b', 3), tailProps('x', 3, 'c', 5))).toBe(false);+ });++ it('re-renders when the tail becomes known or unknown', () => {+ expect(isSameTailRelation(tailProps('a', 1, 'b', 3), tailProps('a', 1, undefined, 3))).toBe(+ false,+ );+ });+});+describe('isSubmittableMessage', () => {it('accepts non-whitespace text without files', () => {expect(isSubmittableMessage('Hello')).toBe(true);diff --git a/client/src/utils/messages.ts b/client/src/utils/messages.tsindex 02e05d5f74..1547e986db 100644--- a/client/src/utils/messages.ts+++ b/client/src/utils/messages.ts@@ -667,21 +667,59 @@ const RELATIVE_TIME_DIVISIONS: { amount: number; unit: Intl.RelativeTimeFormatUn{ amount: Number.POSITIVE_INFINITY, unit: 'year' },];+/**+ * Intl formatters are expensive to construct and every message row formats its+ * timestamp on each render, so they are built once per locale (and clock format).+ */+const resolvedLocales = new Map<string, string | undefined>();+const relativeFormatters = new Map<string, Intl.RelativeTimeFormat>();+const absoluteFormatters = new Map<string, Intl.DateTimeFormat>();+/** Returns the locale only when it is a syntactically valid BCP-47 tag, else undefined. */const resolveLocale = (locale?: string): string | undefined => {if (!locale) {return undefined;}+ if (resolvedLocales.has(locale)) {+ return resolvedLocales.get(locale);+ }+ let resolved: string | undefined;try {Intl.DateTimeFormat.supportedLocalesOf(locale);- return locale;+ resolved = locale;} catch {- return undefined;+ resolved = undefined;+ }+ resolvedLocales.set(locale, resolved);+ return resolved;+};++const getRelativeFormatter = (locale?: string): Intl.RelativeTimeFormat => {+ const key = locale ?? '';+ let formatter = relativeFormatters.get(key);+ if (!formatter) {+ formatter = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });+ relativeFormatters.set(key, formatter);+ }+ return formatter;+};++const getAbsoluteFormatter = (locale?: string, hour12?: boolean): Intl.DateTimeFormat => {+ const key = `${locale ?? ''}|${String(hour12)}`;+ let formatter = absoluteFormatters.get(key);+ if (!formatter) {+ formatter = new Intl.DateTimeFormat(locale, {+ dateStyle: 'medium',+ timeStyle: 'short',+ hour12,+ });+ absoluteFormatters.set(key, formatter);}+ return formatter;};const formatRelativeTime = (from: Date, to: Date, locale?: string): string => {- const formatter = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });+ const formatter = getRelativeFormatter(locale);let duration = (from.getTime() - to.getTime()) / 1000;for (const division of RELATIVE_TIME_DIVISIONS) {if (Math.abs(duration) < division.amount) {@@ -713,11 +751,7 @@ export const getMessageTimestamp = (return {iso: date.toISOString(),relative: formatRelativeTime(date, now, safeLocale),- absolute: new Intl.DateTimeFormat(safeLocale, {- dateStyle: 'medium',- timeStyle: 'short',- hour12,- }).format(date),+ absolute: getAbsoluteFormatter(safeLocale, hour12).format(date),isRecent: Math.abs(now.getTime() - date.getTime()) < RECENT_THRESHOLD_MS,};};@@ -874,6 +908,28 @@ export function areMessageFieldsEqual();}+type TailRelationProps = {+ message?: TMessage | null;+ latestMessageId?: string;+ latestMessageDepth?: number;+};++/**+ * True when moving the thread's tail leaves a row's rendering unchanged. Rows read+ * `latestMessageId` and `latestMessageDepth` only by comparing them to their own id+ * and depth, and for whether a tail is known at all, so a submission or a server id+ * hydration re-renders just the rows entering or leaving the tail.+ */+export function isSameTailRelation(prev: TailRelationProps, next: TailRelationProps): boolean {+ return (+ (prev.latestMessageId == null) === (next.latestMessageId == null) &&+ (prev.latestMessageId === prev.message?.messageId) ===+ (next.latestMessageId === next.message?.messageId) &&+ (prev.latestMessageDepth === prev.message?.depth) ===+ (next.latestMessageDepth === next.message?.depth)+ );+}+/*** Comparator for the memoized message-row wrappers (Message / MessageContent /* MessageParts): identity-compare the scalar props, field-compare the message.diff --git a/e2e/benchmarks-tree/submit-lag.perf.spec.ts b/e2e/benchmarks-tree/submit-lag.perf.spec.tsnew file mode 100644index 0000000000..65523a9dae--- /dev/null+++ b/e2e/benchmarks-tree/submit-lag.perf.spec.ts@@ -0,0 +1,493 @@+import fs from 'node:fs';+import { randomUUID } from 'node:crypto';+import { expect, test } from '@playwright/test';+import type { Page } from '@playwright/test';+import { deleteConversations, deleteMessagesByConversation, withMongo } from '../specs/mock/db';+import { MOCK_ENDPOINTS, messagesView } from '../specs/mock/helpers';+import { buildTreeMessages, TURNS, turnHeading } from './payload';+import { getE2EUser } from '../setup/user';++/**+ * Submit-lag benchmark: what the page does between the Enter press on a long+ * thread and the new turn painting, and while the reply streams in.+ *+ * Dev build (component names, per-commit render reasons):+ * npx playwright test -c e2e/playwright.config.tree-perf.ts submit-lag+ * Built client (production timings; names are minified):+ * npx playwright test -c e2e/playwright.config.tree-perf-prod.ts submit-lag+ *+ * `TREE_PERF_TURNS` sizes the synthetic thread. `SUBMIT_LAG_SOURCE=<export.json>`+ * seeds a real exported conversation (`{ messages }`) instead, re-owned by the e2e+ * user and pointed at the mock endpoint. `SUBMIT_LAG_FLAT=false` measures the+ * recursive renderer. The numbers are printed; nothing is asserted.+ */++const userEmail = getE2EUser().email;+const ENDPOINT = MOCK_ENDPOINTS[0];+const SOURCE = process.env.SUBMIT_LAG_SOURCE;+const FLAT = process.env.SUBMIT_LAG_FLAT !== 'false';+const CONVO = { id: randomUUID(), title: 'Submit lag bench' };+const PROFILE_MS = Number(process.env.SUBMIT_LAG_PROFILE_MS) || 1500;++test.use({ trace: 'off', video: 'off', screenshot: 'off' });++type RawMessage = Record<string, unknown> & { messageId: string; parentMessageId: string };++/** Storage bookkeeping an exported document carries that the seed must not copy. */+const STORAGE_KEYS = new Set(['_id', '_meiliIndex', '_meiliCleanupVersion', 'expiredAt']);++function sourceMessages(): { messages: RawMessage[]; lastText: string } {+ if (!SOURCE) {+ const messages = buildTreeMessages('L') as unknown as RawMessage[];+ return { messages, lastText: turnHeading('L', TURNS) };+ }+ const exported = JSON.parse(fs.readFileSync(SOURCE, 'utf8')) as { messages: RawMessage[] };+ return { messages: exported.messages, lastText: '' };+}++async function seed(): Promise<{ count: number; lastText: string }> {+ const { messages, lastText } = sourceMessages();+ await withMongo(async (db) => {+ const user = await db.collection('users').findOne({ email: userEmail });+ if (!user) {+ throw new Error(`seed: user "${userEmail}" not found`);+ }+ const userId = user._id.toString();+ const now = new Date();+ await db.collection('conversations').insertOne({+ conversationId: CONVO.id,+ title: CONVO.title,+ user: userId,+ endpoint: ENDPOINT.label,+ endpointType: 'custom',+ model: ENDPOINT.model,+ isArchived: false,+ createdAt: now,+ updatedAt: now,+ __v: 0,+ });+ const start = Date.now() - messages.length * 2000;+ const docs = messages.map((message, index) => {+ const fields = Object.entries(message).filter(([key]) => !STORAGE_KEYS.has(key));+ return {+ ...Object.fromEntries(fields),+ conversationId: CONVO.id,+ user: userId,+ endpoint: ENDPOINT.label,+ model: ENDPOINT.model,+ error: false,+ unfinished: false,+ createdAt: new Date(start + index * 1000),+ updatedAt: new Date(start + index * 1000),+ __v: 0,+ };+ });+ await db.collection('messages').insertMany(docs);+ });+ return { count: messages.length, lastText };+}++/**+ * Page-side probe. A devtools-hook stub counts, per commit, which function+ * components actually rendered (DevTools' own `PerformedWork` + child-pointer+ * rule) and their self render time; the walk only runs while `tally` is on so+ * the timing pass carries no instrumentation cost.+ */+const PROBE = `(() => {+ const lag = {+ tally: false,+ t0: null,+ marker: null,+ userRowAt: null,+ commits: [],+ longTasks: [],+ events: [],+ reset(marker) {+ this.t0 = null;+ this.marker = marker;+ this.userRowAt = null;+ this.commits = [];+ this.longTasks = [];+ this.events = [];+ },+ };+ window.__LAG__ = lag;+ window.addEventListener('keydown', (event) => {+ if (event.key === 'Enter' && lag.marker && lag.t0 == null) {+ lag.t0 = performance.now();+ }+ }, true);+ new MutationObserver((records) => {+ if (!lag.marker || lag.userRowAt != null || lag.t0 == null) return;+ for (const record of records) {+ for (const node of record.addedNodes) {+ if (node.nodeType === 1 && !node.closest('form') && (node.textContent || '').includes(lag.marker)) {+ lag.userRowAt = performance.now();+ return;+ }+ }+ }+ }).observe(document, { childList: true, subtree: true });+ try {+ new PerformanceObserver((list) => {+ for (const entry of list.getEntries()) lag.longTasks.push({ start: entry.startTime, duration: entry.duration });+ }).observe({ type: 'longtask', buffered: true });+ new PerformanceObserver((list) => {+ for (const entry of list.getEntries()) {+ lag.events.push({ name: entry.name, start: entry.startTime, duration: entry.duration,+ processing: entry.processingEnd - entry.processingStart, delay: entry.processingStart - entry.startTime });+ }+ }).observe({ type: 'event', durationThreshold: 16, buffered: true });+ } catch (_) {}+ const COMPONENT_TAGS = new Set([0, 1, 11, 14, 15]);+ const nameOf = (fiber) => {+ let type = fiber.type;+ for (let depth = 0; depth < 4 && type; depth += 1) {+ if (typeof type === 'function') return type.displayName || type.name || 'anonymous';+ if (typeof type === 'object') {+ if (type.displayName) return type.displayName;+ type = type.type || type.render;+ continue;+ }+ return String(type);+ }+ return 'anonymous';+ };+ const record = (stats, fiber, mounted) => {+ const name = nameOf(fiber);+ let slot = stats[name];+ if (!slot) { slot = { renders: 0, mounts: 0, time: 0 }; stats[name] = slot; }+ if (mounted) slot.mounts += 1; else slot.renders += 1;+ slot.time += fiber.selfBaseDuration || 0;+ };+ const WATCH = new Set(['MessageContent', 'ContentRender', 'HoverButtons', 'MessageRow', 'Fork',+ 'MessageTimestamp', 'ChatView', 'ChatForm', 'MessagesViewContent', 'List', 'Row', 'Message',+ 'MessageRender', 'ContentParts', 'SiblingSwitch', 'SidebarChatProvider', 'MessageNav']);+ const isPlain = (value) => value != null && typeof value === 'object' && !Array.isArray(value) && !value.$$typeof;+ const reasonsOf = (fiber) => {+ const prev = fiber.alternate;+ const reasons = [];+ const a = prev.memoizedProps || {};+ const b = fiber.memoizedProps || {};+ for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {+ if (key === 'children' || a[key] === b[key]) continue;+ if (isPlain(a[key]) && isPlain(b[key])) {+ const inner = [];+ for (const sub of new Set([...Object.keys(a[key]), ...Object.keys(b[key])])) {+ let av; let bv;+ try { av = a[key][sub]; bv = b[key][sub]; } catch (_) { continue; }+ if (av !== bv) inner.push(sub);+ }+ reasons.push('prop:' + key + (inner.length ? '{' + inner.slice(0, 6).join(',') + '}' : '{same-fields}'));+ } else {+ reasons.push('prop:' + key);+ }+ }+ let dep = fiber.dependencies && fiber.dependencies.firstContext;+ let prevDep = prev.dependencies && prev.dependencies.firstContext;+ while (dep) {+ if (!prevDep || dep.memoizedValue !== prevDep.memoizedValue) {+ const ctx = dep.context;+ const name = ctx.displayName || (ctx.Provider && ctx.Provider.displayName) || 'Context';+ let inner = '';+ if (prevDep && isPlain(dep.memoizedValue) && isPlain(prevDep.memoizedValue)) {+ const changed = [];+ for (const sub of Object.keys(dep.memoizedValue)) {+ if (dep.memoizedValue[sub] !== prevDep.memoizedValue[sub]) changed.push(sub);+ }+ inner = '{' + changed.slice(0, 8).join(',') + '}';+ }+ reasons.push('ctx:' + name + inner);+ }+ dep = dep.next;+ prevDep = prevDep && prevDep.next;+ }+ let hook = fiber.memoizedState;+ let prevHook = prev.memoizedState;+ let index = 0;+ while (hook && prevHook && fiber.tag !== 1) {+ if (hook.queue && hook.memoizedState !== prevHook.memoizedState) {+ const repr = (value) => {+ if (Array.isArray(value)) return 'arr' + value.length + (value.length ? ':' + repr(value[0]) : '');+ if (value && typeof value === 'object') return 'obj{' + Object.keys(value).slice(0, 3).join(',') + '}';+ return String(value).slice(0, 24);+ };+ reasons.push('state#' + index + '(' + repr(prevHook.memoizedState) + '>' + repr(hook.memoizedState) + ')');+ }+ hook = hook.next; prevHook = prevHook.next; index += 1;+ }+ if (!reasons.length) reasons.push('parent');+ return reasons;+ };+ const walk = (rootFiber) => {+ const stats = Object.create(null);+ const why = Object.create(null);+ const stack = [[rootFiber, false]];+ while (stack.length) {+ const [fiber, mounting] = stack.pop();+ const prev = fiber.alternate;+ const mounted = mounting || prev == null;+ if (COMPONENT_TAGS.has(fiber.tag) && (mounted || (fiber.flags & 1) === 1)) {+ record(stats, fiber, mounted);+ const name = nameOf(fiber);+ if (!mounted && WATCH.has(name)) {+ const bucket = (why[name] ??= Object.create(null));+ for (const reason of reasonsOf(fiber)) bucket[reason] = (bucket[reason] || 0) + 1;+ }+ }+ if (mounted || fiber.child !== prev.child) {+ for (let child = fiber.child; child; child = child.sibling) stack.push([child, mounted]);+ }+ }+ return { stats, why };+ };+ let nextId = 1;+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = {+ renderers: new Map(),+ supportsFiber: true,+ inject(renderer) { const id = nextId++; this.renderers.set(id, renderer); return id; },+ onScheduleFiberRoot() {},+ onCommitFiberUnmount() {},+ onPostCommitFiberRoot() {},+ checkDCE() {},+ onCommitFiberRoot(_id, root) {+ if (!lag.tally || lag.t0 == null) return;+ const at = performance.now();+ const { stats, why } = walk(root.current);+ lag.commits.push({ at, walkMs: performance.now() - at, actual: root.current.actualDuration || 0, stats, why });+ },+ };+})();`;++type Slot = { renders: number; mounts: number; time: number };+type Commit = {+ at: number;+ walkMs: number;+ actual: number;+ stats: Record<string, Slot>;+ why: Record<string, Record<string, number>>;+};+type Probe = {+ t0: number | null;+ userRowAt: number | null;+ commits: Commit[];+ longTasks: Array<{ start: number; duration: number }>;+ events: Array<{+ name: string;+ start: number;+ duration: number;+ processing: number;+ delay: number;+ }>;+};++declare global {+ interface Window {+ __LAG__: Probe & { tally: boolean; reset(marker: string): void };+ }+}++type ProfileNode = {+ id: number;+ callFrame: { functionName: string; url: string; lineNumber: number };+ children?: number[];+};++/** Self and inclusive CPU time per function from a CDP profile. */+function summarizeProfile(profile: {+ nodes: ProfileNode[];+ samples: number[];+ timeDeltas: number[];+ startTime: number;+}) {+ const parent = new Map<number, number>();+ const byId = new Map<number, ProfileNode>();+ for (const node of profile.nodes) {+ byId.set(node.id, node);+ for (const child of node.children ?? []) {+ parent.set(child, node.id);+ }+ }+ const keyOf = (node: ProfileNode) => {+ const file = node.callFrame.url.split('/').pop()?.split('?')[0] ?? '';+ return `${node.callFrame.functionName || '(anon)'} ${file}:${node.callFrame.lineNumber + 1}`;+ };+ const self = new Map<string, number>();+ const inclusive = new Map<string, number>();+ for (let i = 0; i < profile.samples.length; i++) {+ const dt = (profile.timeDeltas[i + 1] ?? 0) / 1000;+ const leaf = byId.get(profile.samples[i]);+ if (!leaf) {+ continue;+ }+ self.set(keyOf(leaf), (self.get(keyOf(leaf)) ?? 0) + dt);+ const seen = new Set<string>();+ for (let id: number | undefined = leaf.id; id != null; id = parent.get(id)) {+ const node = byId.get(id);+ if (!node) break;+ const key = keyOf(node);+ if (seen.has(key)) continue;+ seen.add(key);+ inclusive.set(key, (inclusive.get(key) ?? 0) + dt);+ }+ }+ const top = (map: Map<string, number>, n: number) =>+ [...map.entries()]+ .filter(([key]) => !/^\((program|idle|root|garbage collector)\)/.test(key))+ .sort((a, b) => b[1] - a[1])+ .slice(0, n);+ return { self: top(self, 30), inclusive: top(inclusive, 60) };+}++async function submit(page: Page, marker: string, beforeEnter?: () => Promise<void>) {+ const input = page.getByRole('textbox', { name: 'Message input' });+ await input.click();+ await input.fill(`E2E_SLOW_REPLY:${marker}`);+ await page.evaluate((m) => window.__LAG__.reset(m), marker);+ await page.waitForTimeout(300);+ await beforeEnter?.();+ await input.press('Enter');+}++async function waitForTurnEnd(page: Page) {+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeVisible({+ timeout: 30_000,+ });+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeHidden({+ timeout: 120_000,+ });+ await page.waitForTimeout(1500);+}++function reportTimeline(label: string, probe: Probe) {+ const t0 = probe.t0 ?? 0;+ console.log(`\n=== ${label} ===`);+ console.log(+ `enter -> user row in DOM: ${probe.userRowAt ? (probe.userRowAt - t0).toFixed(0) : 'n/a'}ms`,+ );+ const events = probe.events.filter((e) => e.start >= t0 - 50);+ for (const e of events.slice(0, 8)) {+ console.log(+ ` event ${e.name.padEnd(10)} +${(e.start - t0).toFixed(0)}ms duration=${e.duration.toFixed(0)} delay=${e.delay.toFixed(0)} processing=${e.processing.toFixed(0)}`,+ );+ }+ const tasks = probe.longTasks.filter((task) => task.start >= t0 - 50);+ const total = tasks.reduce((sum, task) => sum + task.duration, 0);+ console.log(`long tasks after enter: n=${tasks.length} total=${total.toFixed(0)}ms`);+ for (const task of tasks.slice(0, 40)) {+ console.log(` +${(task.start - t0).toFixed(0).padStart(6)}ms ${task.duration.toFixed(0)}ms`);+ }+}++function reportCommits(label: string, probe: Probe, limit: number) {+ const t0 = probe.t0 ?? 0;+ console.log(`\n=== ${label}: ${probe.commits.length} commits ===`);+ const totals: Record<string, Slot> = Object.create(null);+ for (const [index, commit] of probe.commits.entries()) {+ let renders = 0;+ let mounts = 0;+ let time = 0;+ for (const [name, slot] of Object.entries(commit.stats)) {+ renders += slot.renders;+ mounts += slot.mounts;+ time += slot.time;+ const total = (totals[name] ??= { renders: 0, mounts: 0, time: 0 });+ total.renders += slot.renders;+ total.mounts += slot.mounts;+ total.time += slot.time;+ }+ if (index < limit) {+ const top = Object.entries(commit.stats)+ .sort((a, b) => b[1].time - a[1].time)+ .slice(0, 6)+ .map(+ ([name, slot]) => `${name}(${slot.renders}r/${slot.mounts}m ${slot.time.toFixed(1)}ms)`,+ )+ .join(' ');+ console.log(+ ` #${index} +${(commit.at - t0).toFixed(0)}ms renders=${renders} mounts=${mounts} self=${time.toFixed(0)}ms actual=${commit.actual.toFixed(0)}ms :: ${top}`,+ );+ if (renders > 300) {+ for (const [name, reasons] of Object.entries(commit.why)) {+ const line = Object.entries(reasons)+ .sort((a, b) => b[1] - a[1])+ .slice(0, 6)+ .map(([reason, n]) => `${reason}x${n}`)+ .join(' ');+ console.log(` why ${name.padEnd(20)} ${line}`);+ }+ }+ }+ }+ console.log(' totals by self time:');+ for (const [name, slot] of Object.entries(totals)+ .sort((a, b) => b[1].time - a[1].time)+ .slice(0, 40)) {+ console.log(+ ` ${name.padEnd(36)} renders=${String(slot.renders).padStart(6)} mounts=${String(slot.mounts).padStart(6)} self=${slot.time.toFixed(1)}ms`,+ );+ }+}++test('submit on a long thread', async ({ page }) => {+ test.setTimeout(10 * 60 * 1000);+ const { count, lastText } = await seed();+ console.log(`seeded ${count} messages (${SOURCE ?? 'synthetic'}), flat=${FLAT}`);+ await page.addInitScript((flat: boolean) => {+ localStorage.setItem('textToSpeech', 'false');+ localStorage.setItem('LC_FLAT_THREAD', flat ? 'true' : 'false');+ }, FLAT);+ await page.addInitScript({ content: PROBE });+ await page.goto(`/c/${CONVO.id}`, { timeout: 180_000 });+ if (lastText) {+ await expect(+ messagesView(page).getByRole('heading', { name: lastText, exact: true }).first(),+ ).toBeAttached({ timeout: 120_000 });+ }+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible({+ timeout: 60_000,+ });+ await page.waitForTimeout(4000);+ const nodes = await page.evaluate(() => document.getElementsByTagName('*').length);+ console.log(`DOM elements after load: ${nodes}`);++ const session = await page.context().newCDPSession(page);+ await session.send('Profiler.enable');+ await session.send('Profiler.setSamplingInterval', { interval: 100 });+ await submit(page, `lag-timing-${Date.now()}`, async () => {+ await session.send('Profiler.start');+ });+ await page.waitForTimeout(PROFILE_MS);+ const { profile } = await session.send('Profiler.stop');+ const timing = await page.evaluate(() => window.__LAG__);+ reportTimeline('timing pass (no fiber walk)', timing);+ const summary = summarizeProfile(profile as unknown as Parameters<typeof summarizeProfile>[0]);+ console.log(`\n--- CPU self time (first ${PROFILE_MS}ms after Enter) ---`);+ for (const [key, ms] of summary.self) console.log(` ${ms.toFixed(1).padStart(8)}ms ${key}`);+ console.log(`--- CPU inclusive time (first ${PROFILE_MS}ms after Enter) ---`);+ for (const [key, ms] of summary.inclusive)+ console.log(` ${ms.toFixed(1).padStart(8)}ms ${key}`);+ await waitForTurnEnd(page);++ await page.evaluate(() => {+ window.__LAG__.tally = true;+ });+ await submit(page, `lag-tally-${Date.now()}`);+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeVisible({+ timeout: 30_000,+ });+ await page.waitForTimeout(800);+ const early = await page.evaluate(() => {+ const snapshot = window.__LAG__;+ return { ...snapshot, commits: snapshot.commits.slice() };+ });+ reportCommits('submit commits (first 800ms after Stop visible)', early, 40);+ await waitForTurnEnd(page);+ const full = await page.evaluate(() => window.__LAG__);+ reportCommits('whole turn (submit + stream + finalize)', full, 0);+});++test.afterAll(async () => {+ await deleteMessagesByConversation([CONVO.id]);+ await deleteConversations([CONVO.id]);+});