From 422f3a6f8d23e6679dfcdd1dfd43db952c33f20b Mon Sep 17 00:00:00 2001 From: Danny Avila Date: Sun, 6 Sep 2026 14:30:50 -0400 Subject: [PATCH] =?UTF-8?q?=F0=9F=A7=B6=20feat:=20Flatten=20Active=20Messa?= =?UTF-8?q?ge=20Threads=20Behind=20a=20Flag=20(#15633)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 🧵 feat(client): Flat Message Thread Renderer Behind a Flag Adds a keyed thread index and an O(depth) visible-path resolver so the message list can render as a flat, memoized list instead of one React level per message. The recursive MultiMessage path stays the default; the flat path is enabled per page with the LC_FLAT_THREAD localStorage key or VITE_FLAT_THREAD at build time. Also adds a react-scan/CDP benchmark lane (e2e/benchmarks-tree) that A/Bs both render paths on a seeded 240-row thread, plus a parity config that runs the branch-sensitive mock specs with the flat path on. * 🙈 chore: Ignore the Tree Benchmark Output Directory * 🪢 refactor(client): Move Sibling Selection to Feature-Owned Jotai State Codex round 1 on #15633. The message thread's sibling selection moves out of the Recoil store into a Jotai atom family owned by the thread feature, shared by the recursive and flat renderers, the share view, and the focus, resume and clear writers. Consumers that watch several branch points read them through one derived atom via useSyncExternalStore, so a token-only cache write costs no render. Also keeps the raw cache object as a thread row's reuse identity (file hydration now happens on the row, keyed on the file map), sets the flat flag before the parity config snapshots the server env, and gives the seeded alternate branch consistent turn numbers. * 🧹 style: Sort Imports in the Thread Renderer Files * 📏 chore(e2e): Sample Renderer CPU and Post-GC Heap in the Tree Benchmark Adds a CDP resource probe to each phase: renderer-process CPU time (all threads), JS heap after a forced GC (retained memory rather than allocation churn), DOM node and listener counts. Also lets TREE_PARITY_MATCH pick which mock specs the parity config runs, and derives the deep-switch phase label from the seeded thread size. --- .gitignore | 1 + client/src/components/Chat/ChatView.tsx | 19 +- .../components/Chat/Messages/MessagesView.tsx | 38 +- .../components/Chat/Messages/MultiMessage.tsx | 6 +- .../components/Chat/Messages/Thread/List.tsx | 37 ++ .../components/Chat/Messages/Thread/Row.tsx | 76 ++++ .../components/Chat/Messages/Thread/flag.ts | 15 + .../components/Chat/Messages/Thread/index.ts | 2 + .../components/Chat/Messages/Thread/state.ts | 69 ++++ .../Messages/__tests__/MultiMessage.spec.tsx | 19 +- client/src/components/Share/MultiMessage.tsx | 6 +- client/src/components/Share/ShareView.tsx | 39 +- client/src/hooks/Chat/useChatHelpers.ts | 6 +- .../hooks/Chat/useFocusRegeneratedResponse.ts | 23 +- client/src/hooks/Config/useClearStates.ts | 3 +- .../__tests__/useLatestMessage.spec.tsx | 61 ++- .../src/hooks/Messages/useBuildMessageTree.ts | 15 +- client/src/hooks/Messages/useLatestMessage.ts | 61 +-- client/src/hooks/Messages/useThreadRows.ts | 88 ++++ .../SSE/__tests__/useResumeOnLoad.spec.tsx | 23 +- client/src/hooks/SSE/useResumeOnLoad.ts | 32 +- client/src/store/families.ts | 6 - client/src/utils/thread.spec.ts | 156 +++++++ client/src/utils/thread.ts | 333 +++++++++++++++ client/src/vite-env.d.ts | 1 + e2e/benchmarks-tree/flatenv.ts | 2 + e2e/benchmarks-tree/payload.ts | 99 +++++ e2e/benchmarks-tree/tree-render.perf.spec.ts | 383 ++++++++++++++++++ e2e/playwright.config.tree-parity.ts | 20 + e2e/playwright.config.tree-perf.ts | 41 ++ 30 files changed, 1516 insertions(+), 164 deletions(-) create mode 100644 client/src/components/Chat/Messages/Thread/List.tsx create mode 100644 client/src/components/Chat/Messages/Thread/Row.tsx create mode 100644 client/src/components/Chat/Messages/Thread/flag.ts create mode 100644 client/src/components/Chat/Messages/Thread/index.ts create mode 100644 client/src/components/Chat/Messages/Thread/state.ts create mode 100644 client/src/hooks/Messages/useThreadRows.ts create mode 100644 client/src/utils/thread.spec.ts create mode 100644 client/src/utils/thread.ts create mode 100644 e2e/benchmarks-tree/flatenv.ts create mode 100644 e2e/benchmarks-tree/payload.ts create mode 100644 e2e/benchmarks-tree/tree-render.perf.spec.ts create mode 100644 e2e/playwright.config.tree-parity.ts create mode 100644 e2e/playwright.config.tree-perf.ts diff --git a/.gitignore b/.gitignore index 2920b9b838..3af5dc3ca2 100644 --- a/.gitignore +++ b/.gitignore @@ -94,6 +94,7 @@ archive src/style - official.css /e2e/specs/.test-results/ /e2e/benchmarks/.test-results/ +/e2e/benchmarks-tree/.test-results/ /e2e/.generated/ /e2e/playwright-report/ /e2e/playwright-report-bombadil/ diff --git a/client/src/components/Chat/ChatView.tsx b/client/src/components/Chat/ChatView.tsx index c6316d2ae1..c0bceec1b8 100644 --- a/client/src/components/Chat/ChatView.tsx +++ b/client/src/components/Chat/ChatView.tsx @@ -1,10 +1,10 @@ -import { memo, useCallback } from 'react'; +import { memo, useMemo } from 'react'; import { useRecoilValue } from 'recoil'; import { useForm } from 'react-hook-form'; import { Spinner } from '@librechat/client'; import { useParams } from 'react-router-dom'; import { Constants, buildTree } from 'librechat-data-provider'; -import type { TChatProject, TMessage } from 'librechat-data-provider'; +import type { TChatProject } from 'librechat-data-provider'; import type { ChatFormValues } from '~/common'; import { useAddedResponse, @@ -50,19 +50,12 @@ function ChatView({ index = 0, project }: { index?: number; project?: TChatProje const fileMap = useFileMapContext(); const { - data: messagesTree = null, + data: messages = null, isLoading, isFetching, } = useGetMessagesByConvoId( conversationId ?? '', { - select: useCallback( - (data: TMessage[]) => { - const dataTree = buildTree({ messages: data, fileMap }); - return dataTree?.length === 0 ? null : (dataTree ?? null); - }, - [fileMap], - ), enabled: !!conversationId && conversationId !== Constants.SEARCH, /** Refetch stale caches on mount: navigation invalidates (not removes) * messages now, so a warm conversation renders instantly from cache and @@ -71,6 +64,10 @@ function ChatView({ index = 0, project }: { index?: number; project?: TChatProje }, { isStreaming: isSubmitting }, ); + const messagesTree = useMemo(() => { + const dataTree = buildTree({ messages, fileMap }); + return dataTree?.length === 0 ? null : (dataTree ?? null); + }, [messages, fileMap]); const chatHelpers = useChatHelpers(index, conversationId); const addedChatHelpers = useAddedResponse(); @@ -104,7 +101,7 @@ function ChatView({ index = 0, project }: { index?: number; project?: TChatProje } else if ((isLoading || isNavigating) && !isLandingPage) { content = ; } else if (!isLandingPage) { - content = ; + content = ; } else { content = ; } diff --git a/client/src/components/Chat/Messages/MessagesView.tsx b/client/src/components/Chat/Messages/MessagesView.tsx index 8166a5d9ce..8b6269f754 100644 --- a/client/src/components/Chat/Messages/MessagesView.tsx +++ b/client/src/components/Chat/Messages/MessagesView.tsx @@ -5,11 +5,13 @@ import { Constants } from 'librechat-data-provider'; import { CSSTransition } from 'react-transition-group'; import type { TMessage } from 'librechat-data-provider'; import { useScreenshot, useMessageScrolling, useScrollbarGutter, useLocalize } from '~/hooks'; +import { MessagesViewProvider, useChatContext, useFileMapContext } from '~/Providers'; import { RowMountProvider, useProgressiveRowMount } from '~/hooks/Messages'; -import { MessagesViewProvider, useChatContext } from '~/Providers'; import ScrollToBottom from '~/components/Messages/ScrollToBottom'; +import useThreadRows from '~/hooks/Messages/useThreadRows'; import { steerOverlayHeightFamily } from '~/store/steer'; import { autoScrollAtom } from '~/store/autoScroll'; +import { FLAT_THREAD, ThreadList } from './Thread'; import { fontSizeAtom } from '~/store/fontSize'; import MultiMessage from './MultiMessage'; import MessageNav from './MessageNav'; @@ -94,8 +96,10 @@ const ScrollButton = memo(function ScrollButton({ function MessagesViewContent({ messagesTree: _messagesTree, + messages, }: { messagesTree?: TMessage[] | null; + messages?: TMessage[] | null; }) { const localize = useLocalize(); const fontSize = useAtomValue(fontSizeAtom); @@ -115,6 +119,8 @@ function MessagesViewContent({ useScrollbarGutter(scrollableRef); const { conversationId } = conversation ?? {}; + const fileMap = useFileMapContext(); + const threadRows = useThreadRows(FLAT_THREAD ? messages : null, conversationId, fileMap); const { index, latestMessageDepth } = useChatContext(); const isSubmitting = useRecoilValue(store.isSubmittingFamily(index)); @@ -179,12 +185,20 @@ function MessagesViewContent({ <>
- + {FLAT_THREAD && threadRows ? ( + + ) : ( + + )}
@@ -212,10 +226,16 @@ function MessagesViewContent({ ); } -export default function MessagesView({ messagesTree }: { messagesTree?: TMessage[] | null }) { +export default function MessagesView({ + messagesTree, + messages, +}: { + messagesTree?: TMessage[] | null; + messages?: TMessage[] | null; +}) { return ( - + ); } diff --git a/client/src/components/Chat/Messages/MultiMessage.tsx b/client/src/components/Chat/Messages/MultiMessage.tsx index 5a2d8aa67f..cbf9b2e3f8 100644 --- a/client/src/components/Chat/Messages/MultiMessage.tsx +++ b/client/src/components/Chat/Messages/MultiMessage.tsx @@ -1,16 +1,16 @@ import { memo, useEffect, useRef, useCallback } from 'react'; -import { useRecoilState } from 'recoil'; +import { useAtom } from 'jotai'; import { isAssistantsEndpoint } from 'librechat-data-provider'; import type { TMessage } from 'librechat-data-provider'; import type { ReactElement } from 'react'; import type { TMessageProps } from '~/common'; import EventSubagentActivityGroup from '~/components/Chat/Subagents/EventSubagentActivityGroup'; import MessageContent from '~/components/Messages/MessageContent'; +import { siblingIdxFamily, siblingKey } from './Thread/state'; import { useRowMountWindow } from '~/hooks/Messages'; import { hasParallelLanes } from '~/utils/lanes'; import MessageParts from './MessageParts'; import Message from './Message'; -import store from '~/store'; /** First-run sentinel for `parentRef`: `messageId` itself may legitimately be * null/undefined at the root level, so those can't mark "not yet bound". */ @@ -23,7 +23,7 @@ function MultiMessage({ currentEditId, setCurrentEditId, }: TMessageProps) { - const [siblingIdx, setSiblingIdx] = useRecoilState(store.messagesSiblingIdxFamily(messageId)); + const [siblingIdx, setSiblingIdx] = useAtom(siblingIdxFamily(siblingKey(messageId))); const mountWindow = useRowMountWindow(); const setSiblingIdxRev = useCallback( diff --git a/client/src/components/Chat/Messages/Thread/List.tsx b/client/src/components/Chat/Messages/Thread/List.tsx new file mode 100644 index 0000000000..c3f3032992 --- /dev/null +++ b/client/src/components/Chat/Messages/Thread/List.tsx @@ -0,0 +1,37 @@ +import { memo } from 'react'; +import type { ThreadRow } from '~/utils/thread'; +import type { TMessageProps } from '~/common'; +import { useRowMountWindow } from '~/hooks/Messages'; +import Row from './Row'; + +type ListProps = { + rows: ThreadRow[]; + currentEditId: TMessageProps['currentEditId']; + setCurrentEditId: TMessageProps['setCurrentEditId']; +}; + +/** + * Flat thread renderer. Rows are keyed by position, exactly the reconciliation + * the recursive renderer relied on: message ids change across the streaming + * lifecycle, while a row's position does not, so the streaming row keeps its + * component instance and a sibling switch reuses the instances below it. + */ +function List({ rows, currentEditId, setCurrentEditId }: ListProps) { + const mountWindow = useRowMountWindow(); + return ( + <> + {rows.map((row) => + mountWindow == null || (row.depth >= mountWindow.start && row.depth <= mountWindow.end) ? ( + + ) : null, + )} + + ); +} + +export default memo(List); diff --git a/client/src/components/Chat/Messages/Thread/Row.tsx b/client/src/components/Chat/Messages/Thread/Row.tsx new file mode 100644 index 0000000000..7edb9568b1 --- /dev/null +++ b/client/src/components/Chat/Messages/Thread/Row.tsx @@ -0,0 +1,76 @@ +import { memo, useCallback } from 'react'; +import { useSetAtom } from 'jotai'; +import { isAssistantsEndpoint } from 'librechat-data-provider'; +import type { ThreadRow } from '~/utils/thread'; +import type { TMessageProps } from '~/common'; +import EventSubagentActivityGroup from '~/components/Chat/Subagents/EventSubagentActivityGroup'; +import MessageContent from '~/components/Messages/MessageContent'; +import { hasParallelLanes } from '~/utils/lanes'; +import MessageParts from '../MessageParts'; +import { siblingIdxFamily } from './state'; +import Message from '../Message'; + +type RowProps = { + row: ThreadRow; + currentEditId: TMessageProps['currentEditId']; + setCurrentEditId: TMessageProps['setCurrentEditId']; +}; + +/** One visible row of the flat thread: the message plus its activity group. */ +function Row({ row, currentEditId, setCurrentEditId }: RowProps) { + const { message, siblingIdx, siblingCount, parentKey } = row; + const setSiblingIdx = useSetAtom(siblingIdxFamily(parentKey)); + const setSiblingIdxRev = useCallback( + (value: number) => { + setSiblingIdx(siblingCount - value - 1); + }, + [siblingCount, setSiblingIdx], + ); + + const sharedProps = { + message, + currentEditId, + setCurrentEditId, + siblingIdx: siblingCount - siblingIdx - 1, + siblingCount, + setSiblingIdx: setSiblingIdxRev, + }; + + let content: JSX.Element; + if (isAssistantsEndpoint(message.endpoint) && message.content) { + content = ; + } else if (message.content) { + content = ; + } else { + content = ; + } + + let activityParentMessageIds: string[] = []; + if (message.isCreatedByUser) { + if (row.childCount === 0) activityParentMessageIds = [message.messageId]; + } else { + activityParentMessageIds = [message.messageId, message.parentMessageId].filter( + (id): id is string => typeof id === 'string' && id.length > 0, + ); + } + const isEditingActivityAnchor = + typeof currentEditId === 'string' && activityParentMessageIds.includes(currentEditId); + const hasParallelContent = !message.isCreatedByUser && hasParallelLanes(message.content); + + return ( + <> + {content} + {!isEditingActivityAnchor && activityParentMessageIds.length > 0 ? ( +
+ +
+ ) : null} + + ); +} + +export default memo(Row); diff --git a/client/src/components/Chat/Messages/Thread/flag.ts b/client/src/components/Chat/Messages/Thread/flag.ts new file mode 100644 index 0000000000..bce002d6ff --- /dev/null +++ b/client/src/components/Chat/Messages/Thread/flag.ts @@ -0,0 +1,15 @@ +/** + * Prototype switch for the flat thread renderer, read once per page load. + * `LC_FLAT_THREAD` in localStorage wins; `VITE_FLAT_THREAD` sets the default. + */ +function readFlag(): boolean { + const fallback = import.meta.env.VITE_FLAT_THREAD === 'true'; + try { + const stored = localStorage.getItem('LC_FLAT_THREAD'); + return stored == null ? fallback : stored === 'true'; + } catch { + return fallback; + } +} + +export const FLAT_THREAD = readFlag(); diff --git a/client/src/components/Chat/Messages/Thread/index.ts b/client/src/components/Chat/Messages/Thread/index.ts new file mode 100644 index 0000000000..ade2061285 --- /dev/null +++ b/client/src/components/Chat/Messages/Thread/index.ts @@ -0,0 +1,2 @@ +export { default as ThreadList } from './List'; +export { FLAT_THREAD } from './flag'; diff --git a/client/src/components/Chat/Messages/Thread/state.ts b/client/src/components/Chat/Messages/Thread/state.ts new file mode 100644 index 0000000000..155d7c7673 --- /dev/null +++ b/client/src/components/Chat/Messages/Thread/state.ts @@ -0,0 +1,69 @@ +import { useCallback, useMemo, useRef, useSyncExternalStore } from 'react'; +import { atom, useStore } from 'jotai'; +import { atomFamily } from 'jotai/utils'; +import type { Atom } from 'jotai'; + +/** + * Sibling selection of the message thread: per parent, the REVERSED index of + * the child on display (0 = newest). Feature-owned state, shared by the + * recursive and flat renderers, the share view, and the writers that focus a + * regenerated response, restore a resumed branch, or clear a conversation. + */ + +/** Recoil keyed `null` and `undefined` parents distinctly from any id; one sentinel keeps that. */ +export const NULL_SIBLING_KEY = '__null_parent__'; + +export const siblingKey = (parentId: string | null | undefined): string => + parentId ?? NULL_SIBLING_KEY; + +export const siblingIdxFamily = atomFamily((_key: string) => atom(0)); + +/** Read-only atom over the selections of the given parents, for one subscription per consumer. */ +export function siblingIndexesAtom(keys: readonly string[]): Atom> { + return atom((get) => { + const indexes: Record = {}; + for (const key of keys) { + indexes[key] = get(siblingIdxFamily(key)); + } + return indexes; + }); +} + +function sameKeys(a: readonly string[], b: readonly string[]): boolean { + if (a === b) { + return true; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i += 1) { + if (a[i] !== b[i]) { + return false; + } + } + return true; +} + +/** + * Subscribes to the selections of `parentKeys` through one derived atom that + * is only replaced when the KEYS change by content: callers derive the key + * list from the messages cache on every write, and a fresh atom per write + * would hand every consumer a new value object and a render per delta. + * Read through `useSyncExternalStore` so a consumer renders exactly when the + * selection object changes, with no mount-time re-render. + */ +export function useSiblingIndexes(parentKeys: readonly string[]): Record { + const jotaiStore = useStore(); + const stableRef = useRef(parentKeys); + if (!sameKeys(stableRef.current, parentKeys)) { + stableRef.current = parentKeys; + } + const stableKeys = stableRef.current; + const indexesAtom = useMemo(() => siblingIndexesAtom(stableKeys), [stableKeys]); + const subscribe = useCallback( + (onChange: () => void) => jotaiStore.sub(indexesAtom, onChange), + [jotaiStore, indexesAtom], + ); + const read = useCallback(() => jotaiStore.get(indexesAtom), [jotaiStore, indexesAtom]); + return useSyncExternalStore(subscribe, read, read); +} diff --git a/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx b/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx index d5bf5ce960..92203969af 100644 --- a/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx +++ b/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx @@ -1,5 +1,6 @@ import React from 'react'; import { RecoilRoot } from 'recoil'; +import { Provider as JotaiProvider } from 'jotai'; import { fireEvent, render, screen } from '@testing-library/react'; import type { TMessage } from 'librechat-data-provider'; import MultiMessage from '../MultiMessage'; @@ -63,14 +64,16 @@ const msg = (messageId: string): TMessage => const tree = (ids: string[]) => ids.map((id) => msg(id)); const treeElement = (ids: string[]) => ( - - - + + + + + ); const displayed = () => screen.getAllByTestId('row')[0].textContent; diff --git a/client/src/components/Share/MultiMessage.tsx b/client/src/components/Share/MultiMessage.tsx index 24ec2a5dd3..dc70b7151f 100644 --- a/client/src/components/Share/MultiMessage.tsx +++ b/client/src/components/Share/MultiMessage.tsx @@ -1,10 +1,10 @@ import { useEffect } from 'react'; -import { useRecoilState } from 'recoil'; +import { useAtom } from 'jotai'; import type { TMessage } from 'librechat-data-provider'; import type { TMessageProps } from '~/common'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import Message from './Message'; -import store from '~/store'; export default function MultiMessage({ // messageId is used recursively here @@ -13,7 +13,7 @@ export default function MultiMessage({ currentEditId, setCurrentEditId, }: TMessageProps) { - const [siblingIdx, setSiblingIdx] = useRecoilState(store.messagesSiblingIdxFamily(messageId)); + const [siblingIdx, setSiblingIdx] = useAtom(siblingIdxFamily(siblingKey(messageId))); const setSiblingIdxRev = (value: number) => { setSiblingIdx((messagesTree?.length ?? 0) - value - 1); diff --git a/client/src/components/Share/ShareView.tsx b/client/src/components/Share/ShareView.tsx index 13228a35a0..5a8cf35ac3 100644 --- a/client/src/components/Share/ShareView.tsx +++ b/client/src/components/Share/ShareView.tsx @@ -1,8 +1,9 @@ import { memo, useState, useCallback, useContext } from 'react'; import Cookies from 'js-cookie'; +import { useStore } from 'jotai'; import { buildTree } from 'librechat-data-provider'; +import { useRecoilState, useRecoilValue } from 'recoil'; import { useParams, useNavigate } from 'react-router-dom'; -import { useRecoilState, useRecoilValue, useRecoilCallback } from 'recoil'; import { useGetSharedMessages } from 'librechat-data-provider/react-query'; import { CalendarDays, ExternalLink, RefreshCw, Settings, MessageSquarePlus } from 'lucide-react'; import { @@ -21,6 +22,7 @@ import { } from '@librechat/client'; import SharedSubagentActivityDialog from '~/components/Chat/Subagents/SharedSubagentActivityDialog'; import { cn, DEFAULT_APP_TITLE, getResponseStatus, selectActiveBranchTail } from '~/utils'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import { useLocalize, useDocumentTitle, useAuthContext } from '~/hooks'; import { ThemeSelector, LangSelector } from '~/components/Appearance'; import { ShareMessagesProvider } from './ShareMessagesProvider'; @@ -43,6 +45,7 @@ function SharedView() { const { isAuthReady } = useAuthContext(); const { theme, setTheme } = useContext(ThemeContext); const { shareId } = useParams(); + const jotaiStore = useStore(); const { data: config } = useGetSharedStartupConfig(shareId, { enabled: isAuthReady }); const { data, isLoading, isFetching, refetch } = useGetSharedMessages(shareId ?? '', { enabled: isAuthReady, @@ -89,26 +92,20 @@ function SharedView() { * the root on SHARED_CONVO_KEY. An index is sent (not id or createdAt) because * shared ids are re-anonymized per request and createdAt can collide, while * the payload order is stable across requests. */ - const getActiveTargetIndex = useRecoilCallback( - ({ snapshot }) => - () => { - const messages = data?.messages; - if (messages == null || messages.length === 0) { - return undefined; - } - const getSiblingIndex = (parentMessageId: string | null | undefined) => - snapshot - .getLoadable(store.messagesSiblingIdxFamily(parentMessageId ?? SHARED_CONVO_KEY)) - .getValue() ?? 0; - const tail = selectActiveBranchTail(messages, SHARED_CONVO_KEY, getSiblingIndex); - if (tail == null) { - return undefined; - } - const index = messages.findIndex((message) => message.messageId === tail.messageId); - return index >= 0 ? index : undefined; - }, - [data?.messages], - ); + const getActiveTargetIndex = useCallback(() => { + const messages = data?.messages; + if (messages == null || messages.length === 0) { + return undefined; + } + const getSiblingIndex = (parentMessageId: string | null | undefined) => + jotaiStore.get(siblingIdxFamily(siblingKey(parentMessageId ?? SHARED_CONVO_KEY))); + const tail = selectActiveBranchTail(messages, SHARED_CONVO_KEY, getSiblingIndex); + if (tail == null) { + return undefined; + } + const index = messages.findIndex((message) => message.messageId === tail.messageId); + return index >= 0 ? index : undefined; + }, [data?.messages, jotaiStore]); const { mutate: forkSharedConvo } = forkShare; const handleContinue = useCallback(() => { diff --git a/client/src/hooks/Chat/useChatHelpers.ts b/client/src/hooks/Chat/useChatHelpers.ts index e83f9eaa0f..e99ede8eb0 100644 --- a/client/src/hooks/Chat/useChatHelpers.ts +++ b/client/src/hooks/Chat/useChatHelpers.ts @@ -1,4 +1,5 @@ import { useCallback, useMemo, useRef, useState } from 'react'; +import { useSetAtom } from 'jotai'; import { useQueryClient } from '@tanstack/react-query'; import { Constants, QueryKeys, isAssistantsEndpoint } from 'librechat-data-provider'; import { useRecoilState, useRecoilValue, useSetRecoilState, useRecoilCallback } from 'recoil'; @@ -9,6 +10,7 @@ import { supportsGenerationProtocolV2, } from '~/data-provider'; import { useLatestMessage, useLatestMessageId } from '~/hooks/Messages/useLatestMessage'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import useChatFunctions from '~/hooks/Chat/useChatFunctions'; import useSteerConvert from '~/hooks/Chat/useSteerConvert'; import { resolveAbortSteerTarget } from '~/utils'; @@ -104,8 +106,8 @@ export default function useChatHelpers(index = 0, paramId?: string) { const latestMessageRef = useRef(latestMessage); latestMessageRef.current = latestMessage; - const setSiblingIdx = useSetRecoilState( - store.messagesSiblingIdxFamily(latestMessage?.parentMessageId ?? null), + const setSiblingIdx = useSetAtom( + siblingIdxFamily(siblingKey(latestMessage?.parentMessageId ?? null)), ); const setMessages = useCallback( diff --git a/client/src/hooks/Chat/useFocusRegeneratedResponse.ts b/client/src/hooks/Chat/useFocusRegeneratedResponse.ts index 5d5ad3abc0..2c2ab63f8e 100644 --- a/client/src/hooks/Chat/useFocusRegeneratedResponse.ts +++ b/client/src/hooks/Chat/useFocusRegeneratedResponse.ts @@ -1,5 +1,6 @@ -import { useRecoilCallback } from 'recoil'; -import store from '~/store'; +import { useCallback } from 'react'; +import { useStore } from 'jotai'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; /** * Focus a regenerated response's fork on its newest sibling. A regeneration @@ -12,14 +13,14 @@ import store from '~/store'; * event so there is no flash on the kept sibling in between. */ export default function useFocusRegeneratedResponse() { - return useRecoilCallback( - ({ set }) => - (parentMessageId?: string | null) => { - if (parentMessageId == null) { - return; - } - set(store.messagesSiblingIdxFamily(parentMessageId), 0); - }, - [], + const jotaiStore = useStore(); + return useCallback( + (parentMessageId?: string | null) => { + if (parentMessageId == null) { + return; + } + jotaiStore.set(siblingIdxFamily(siblingKey(parentMessageId)), 0); + }, + [jotaiStore], ); } diff --git a/client/src/hooks/Config/useClearStates.ts b/client/src/hooks/Config/useClearStates.ts index e19e8073a4..0dde3e2630 100644 --- a/client/src/hooks/Config/useClearStates.ts +++ b/client/src/hooks/Config/useClearStates.ts @@ -1,5 +1,6 @@ import { useStore } from 'jotai'; import { useRecoilCallback } from 'recoil'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import { showSkillsPopoverFamily } from '~/components/Chat/Input/skillsState'; import { clearLocalStorage } from '~/utils/localStorage'; import store from '~/store'; @@ -53,7 +54,7 @@ export default function useClearStates() { reset(store.globalAudioPlayingFamily(key)); reset(store.activeRunFamily(key)); reset(store.audioRunFamily(key)); - reset(store.messagesSiblingIdxFamily(key.toString())); + jotaiStore.set(siblingIdxFamily(siblingKey(key.toString())), 0); } clearLocalStorage(skipFirst); diff --git a/client/src/hooks/Messages/__tests__/useLatestMessage.spec.tsx b/client/src/hooks/Messages/__tests__/useLatestMessage.spec.tsx index 89f769c07d..f1a260da0a 100644 --- a/client/src/hooks/Messages/__tests__/useLatestMessage.spec.tsx +++ b/client/src/hooks/Messages/__tests__/useLatestMessage.spec.tsx @@ -1,6 +1,7 @@ import React from 'react'; import { act, renderHook } from '@testing-library/react'; import { RecoilRoot, type MutableSnapshot } from 'recoil'; +import { Provider as JotaiProvider, createStore } from 'jotai'; import { MemoryRouter, Route, Routes } from 'react-router-dom'; import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; import { QueryKeys, type TConversation, type TMessage } from 'librechat-data-provider'; @@ -11,6 +12,7 @@ import { useGetLatestMessage, } from '~/hooks/Messages/useLatestMessage'; import { getBranchSiblingIndexesForTarget, getMessageBranchSiblingParentIds } from '~/utils'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import store from '~/store'; function createQueryClient() { @@ -69,17 +71,20 @@ function createWrapper( queryClient = createQueryClient(), initializeState?: (snapshot: MutableSnapshot) => void, initialEntry = '/c/conversation-1', + jotaiStore = createStore(), ) { return function Wrapper({ children }: { children: React.ReactNode }) { return ( - - - - - - - + + + + + + + + + ); }; @@ -166,11 +171,17 @@ describe('useLatestMessage', () => { ], ); + const jotaiStore = createStore(); + jotaiStore.set(siblingIdxFamily(siblingKey(userMessage.messageId)), 1); const { result } = renderHook(() => useLatestMessage(0), { - wrapper: createWrapper(queryClient, ({ set }) => { - set(store.conversationByIndex(0), conversation); - set(store.messagesSiblingIdxFamily(userMessage.messageId), 1); - }), + wrapper: createWrapper( + queryClient, + ({ set }) => { + set(store.conversationByIndex(0), conversation); + }, + undefined, + jotaiStore, + ), }); expect(result.current).toEqual( @@ -194,11 +205,17 @@ describe('useLatestMessage', () => { ], ); + const jotaiStore = createStore(); + jotaiStore.set(siblingIdxFamily(siblingKey(userMessage.messageId)), 99); const { result } = renderHook(() => useLatestMessage(0), { - wrapper: createWrapper(queryClient, ({ set }) => { - set(store.conversationByIndex(0), conversation); - set(store.messagesSiblingIdxFamily(userMessage.messageId), 99); - }), + wrapper: createWrapper( + queryClient, + ({ set }) => { + set(store.conversationByIndex(0), conversation); + }, + undefined, + jotaiStore, + ), }); expect(result.current).toEqual( @@ -382,11 +399,17 @@ describe('useGetLatestMessage', () => { ], ); + const jotaiStore = createStore(); + jotaiStore.set(siblingIdxFamily(siblingKey(userMessage.messageId)), 1); const { result } = renderHook(() => useGetLatestMessage(0), { - wrapper: createWrapper(queryClient, ({ set }) => { - set(store.conversationByIndex(0), conversation); - set(store.messagesSiblingIdxFamily(userMessage.messageId), 1); - }), + wrapper: createWrapper( + queryClient, + ({ set }) => { + set(store.conversationByIndex(0), conversation); + }, + undefined, + jotaiStore, + ), }); expect(result.current()).toEqual( diff --git a/client/src/hooks/Messages/useBuildMessageTree.ts b/client/src/hooks/Messages/useBuildMessageTree.ts index 6ac9e57043..23c43fd5df 100644 --- a/client/src/hooks/Messages/useBuildMessageTree.ts +++ b/client/src/hooks/Messages/useBuildMessageTree.ts @@ -1,13 +1,14 @@ -import { useRecoilCallback } from 'recoil'; +import { useCallback } from 'react'; +import { useStore } from 'jotai'; import type { TMessage } from 'librechat-data-provider'; -import store from '~/store'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; export default function useBuildMessageTree() { - const getSiblingIdx = useRecoilCallback( - ({ snapshot }) => - async (messageId: string | null | undefined) => - await snapshot.getPromise(store.messagesSiblingIdxFamily(messageId)), - [], + const jotaiStore = useStore(); + const getSiblingIdx = useCallback( + async (messageId: string | null | undefined) => + jotaiStore.get(siblingIdxFamily(siblingKey(messageId))), + [jotaiStore], ); // return an object or an array based on branches and recursive option diff --git a/client/src/hooks/Messages/useLatestMessage.ts b/client/src/hooks/Messages/useLatestMessage.ts index 7766f40e0d..1fb8483fb9 100644 --- a/client/src/hooks/Messages/useLatestMessage.ts +++ b/client/src/hooks/Messages/useLatestMessage.ts @@ -1,35 +1,20 @@ -import { useCallback } from 'react'; +import { useCallback, useMemo } from 'react'; +import { useStore } from 'jotai'; +import { useRecoilValue } from 'recoil'; import { useParams } from 'react-router-dom'; import { Constants, QueryKeys } from 'librechat-data-provider'; import { useQuery, useQueryClient } from '@tanstack/react-query'; -import { selectorFamily, useRecoilValue, useRecoilCallback } from 'recoil'; import type { TMessage } from 'librechat-data-provider'; +import { + siblingIdxFamily, + siblingKey, + useSiblingIndexes, +} from '~/components/Chat/Messages/Thread/state'; import { getMessageBranchSiblingParentIds, selectActiveBranchTail } from '~/utils'; import store from '~/store'; -const NULL_PARENT_KEY = '__null_parent__'; const EMPTY_PARENT_IDS: (string | null)[] = []; - -const getParentLookupKey = (parentMessageId: string | null | undefined) => - parentMessageId ?? NULL_PARENT_KEY; - -const siblingIndexesByParentSelector = selectorFamily< - Record, - readonly (string | null)[] ->({ - key: 'latestMessageSiblingIndexesByParent', - get: - (parentIds) => - ({ get }) => { - const indexes: Record = {}; - - for (const parentId of parentIds) { - indexes[getParentLookupKey(parentId)] = get(store.messagesSiblingIdxFamily(parentId)); - } - - return indexes; - }, -}); +const getParentLookupKey = siblingKey; function useMessagesCacheSelect( messagesQueryId: string | null | undefined, @@ -85,7 +70,8 @@ function useLatestMessageSiblingIndexes( [rootSiblingKey], ); const parentIds = useMessagesCacheSelect(messagesQueryId, selectParentIds) ?? EMPTY_PARENT_IDS; - return useRecoilValue(siblingIndexesByParentSelector(parentIds)); + const parentKeys = useMemo(() => parentIds.map(siblingKey), [parentIds]); + return useSiblingIndexes(parentKeys); } export function useLatestMessage( @@ -175,21 +161,18 @@ export function useGetLatestMessage( messagesQueryIdOverride?: string | null, ): () => TMessage | null { const queryClient = useQueryClient(); + const jotaiStore = useStore(); const conversationId = useRecoilValue(store.conversationIdByIndex(index)); const messagesQueryId = useLatestMessagesQueryId(index, conversationId, messagesQueryIdOverride); - return useRecoilCallback( - ({ snapshot }) => - (): TMessage | null => { - if (!messagesQueryId) { - return null; - } - const messages = - queryClient.getQueryData([QueryKeys.messages, messagesQueryId]) ?? []; - return selectActiveBranchTail(messages, conversationId, (parentId) => - snapshot.getLoadable(store.messagesSiblingIdxFamily(parentId)).getValue(), - ); - }, - [queryClient, conversationId, messagesQueryId], - ); + return useCallback((): TMessage | null => { + if (!messagesQueryId) { + return null; + } + const messages = + queryClient.getQueryData([QueryKeys.messages, messagesQueryId]) ?? []; + return selectActiveBranchTail(messages, conversationId, (parentId) => + jotaiStore.get(siblingIdxFamily(siblingKey(parentId))), + ); + }, [queryClient, jotaiStore, conversationId, messagesQueryId]); } diff --git a/client/src/hooks/Messages/useThreadRows.ts b/client/src/hooks/Messages/useThreadRows.ts new file mode 100644 index 0000000000..beae49b4ed --- /dev/null +++ b/client/src/hooks/Messages/useThreadRows.ts @@ -0,0 +1,88 @@ +import { useEffect, useMemo, useRef } from 'react'; +import { useStore } from 'jotai'; +import type { TFile, TMessage } from 'librechat-data-provider'; +import type { ThreadIndex, ThreadRow } from '~/utils/thread'; +import { + ROOT_KEY, + buildThreadIndex, + changedParentKeys, + reconcileSiblingIdx, + resolveThreadRows, +} from '~/utils/thread'; +import { + siblingIdxFamily, + siblingKey, + useSiblingIndexes, +} from '~/components/Chat/Messages/Thread/state'; + +const EMPTY_KEYS: string[] = []; + +/** + * The visible thread as a flat list of rows, derived from the messages cache + * plus the sibling selection of the branch points only. A streaming delta + * changes one message object, so every other row is reused by reference and + * the memoized row components bail without a field diff. + * + * Selection reconciliation (follow an appended sibling, keep the viewed one + * through churn) runs once per index change over the parents whose children + * list actually changed, instead of once per rendered level. + */ +export default function useThreadRows( + messages: TMessage[] | null | undefined, + rootKey: string | null | undefined, + fileMap?: Record, +): ThreadRow[] | null { + const jotaiStore = useStore(); + const rootSiblingKey = siblingKey(rootKey); + const index = useMemo( + () => (messages ? buildThreadIndex(messages, fileMap) : null), + [messages, fileMap], + ); + const branchKeys = useMemo( + () => + index + ? index.branchParentKeys.map((key) => (key === ROOT_KEY ? rootSiblingKey : key)) + : EMPTY_KEYS, + [index, rootSiblingKey], + ); + const siblingIndexes = useSiblingIndexes(branchKeys); + + const previousRowsRef = useRef(null); + const rows = useMemo(() => { + if (!index) { + return null; + } + const next = resolveThreadRows( + index, + rootSiblingKey, + (key) => siblingIndexes[key] ?? 0, + previousRowsRef.current, + ); + previousRowsRef.current = next; + return next; + }, [index, rootSiblingKey, siblingIndexes]); + + const previousIndexRef = useRef<{ rootKey: string; index: ThreadIndex } | null>(null); + useEffect(() => { + if (!index) { + previousIndexRef.current = null; + return; + } + const previous = previousIndexRef.current; + previousIndexRef.current = { rootKey: rootSiblingKey, index }; + const previousIndex = previous && previous.rootKey === rootSiblingKey ? previous.index : null; + for (const key of changedParentKeys(previousIndex, index)) { + const atom = siblingIdxFamily(key === ROOT_KEY ? rootSiblingKey : key); + const nextIdx = reconcileSiblingIdx( + previousIndex?.children.get(key), + index.children.get(key) ?? [], + jotaiStore.get(atom), + ); + if (nextIdx != null) { + jotaiStore.set(atom, nextIdx); + } + } + }, [index, rootSiblingKey, jotaiStore]); + + return rows; +} diff --git a/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx b/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx index e3a5d039e8..7261870e77 100644 --- a/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx +++ b/client/src/hooks/SSE/__tests__/useResumeOnLoad.spec.tsx @@ -1,11 +1,13 @@ import { renderHook, act } from '@testing-library/react'; import { RecoilRoot, useRecoilValue, useSetRecoilState } from 'recoil'; import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; +import { Provider as JotaiProvider, createStore, useAtomValue } from 'jotai'; import { Constants, ContentTypes, QueryKeys } from 'librechat-data-provider'; import type { TMessage, TConversation, TSubmission } from 'librechat-data-provider'; import type { MutableSnapshot } from 'recoil'; import type { ReactNode } from 'react'; import type { PendingSteer, QueuedMessage } from '~/store/families'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import useResumeOnLoad from '../useResumeOnLoad'; import store from '~/store'; @@ -110,6 +112,7 @@ function renderUseResumeOnLoad({ onSubmissionStart?: (submissionStart: number | null) => void; }) { const getMessages = jest.fn(getMessagesOverride ?? (() => messages)); + const jotaiStore = createStore(); const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } }, }); @@ -158,7 +161,7 @@ function renderUseResumeOnLoad({ return null; }; const SiblingIndexProbe = () => { - const siblingIndex = useRecoilValue(store.messagesSiblingIdxFamily(siblingIndexParentId)); + const siblingIndex = useAtomValue(siblingIdxFamily(siblingKey(siblingIndexParentId))); if (siblingIndexParentId) { onSiblingIndex?.(siblingIndex); } @@ -167,14 +170,16 @@ function renderUseResumeOnLoad({ const wrapper = ({ children }: { children: ReactNode }) => ( - - - - - - - {children} - + + + + + + + + {children} + + ); diff --git a/client/src/hooks/SSE/useResumeOnLoad.ts b/client/src/hooks/SSE/useResumeOnLoad.ts index 06b7e6c2e7..6d091daa14 100644 --- a/client/src/hooks/SSE/useResumeOnLoad.ts +++ b/client/src/hooks/SSE/useResumeOnLoad.ts @@ -1,4 +1,5 @@ -import { useEffect, useMemo, useRef, useState } from 'react'; +import { useCallback, useEffect, useMemo, useRef, useState } from 'react'; +import { useStore } from 'jotai'; import { useQueryClient } from '@tanstack/react-query'; import { useSetRecoilState, useRecoilValue, useRecoilCallback } from 'recoil'; import { @@ -33,6 +34,7 @@ import { getGenerationProtocolVersion, supportsGenerationProtocolV2, } from '~/data-provider/SSE/protocol'; +import { siblingIdxFamily, siblingKey } from '~/components/Chat/Messages/Thread/state'; import useSteerConvert from '~/hooks/Chat/useSteerConvert'; import store from '~/store'; @@ -254,6 +256,7 @@ export default function useResumeOnLoad( runIndex = 0, messagesLoaded = true, ) { + const jotaiStore = useStore(); const queryClient = useQueryClient(); const setSubmission = useSetRecoilState(store.submissionByIndex(runIndex)); const setSubmissionStart = useSetRecoilState(store.submissionStartFamily(runIndex)); @@ -293,21 +296,20 @@ export default function useResumeOnLoad( * enter a resume→404→resume loop. A genuinely newer handoff has a different * createdAt key and remains eligible. */ const consumedHandoffGenerationRef = useRef(null); - const restoreResumeBranch = useRecoilCallback( - ({ set }) => - (resumeState: Agents.ResumeState, messages: TMessage[], activeConversationId: string) => { - const targetMessageId = getResumeBranchTargetMessageId(resumeState, messages); - const branchIndexes = getBranchSiblingIndexesForTarget( - messages, - targetMessageId, - activeConversationId, - ); + const restoreResumeBranch = useCallback( + (resumeState: Agents.ResumeState, messages: TMessage[], activeConversationId: string) => { + const targetMessageId = getResumeBranchTargetMessageId(resumeState, messages); + const branchIndexes = getBranchSiblingIndexesForTarget( + messages, + targetMessageId, + activeConversationId, + ); - for (const { parentMessageId, siblingIdx } of branchIndexes) { - set(store.messagesSiblingIdxFamily(parentMessageId), siblingIdx); - } - }, - [], + for (const { parentMessageId, siblingIdx } of branchIndexes) { + jotaiStore.set(siblingIdxFamily(siblingKey(parentMessageId)), siblingIdx); + } + }, + [jotaiStore], ); /** Restore pending-steer chips for steers the server still has queued diff --git a/client/src/store/families.ts b/client/src/store/families.ts index cadd2af9b1..3bfb45ec9d 100644 --- a/client/src/store/families.ts +++ b/client/src/store/families.ts @@ -676,11 +676,6 @@ const audioRunFamily = atomFamily({ default: null, }); -const messagesSiblingIdxFamily = atomFamily({ - key: 'messagesSiblingIdx', - default: 0, -}); - /** Setter-only access to the conversation atom: registers the key like * `useCreateConversationAtom` but never subscribes to the value, so callers * that only write (navigation, per-row actions) don't re-render on every @@ -796,7 +791,6 @@ export default { isSubmittingFamily, optionSettingsFamily, showPopoverFamily, - messagesSiblingIdxFamily, anySubmittingSelector, allConversationsSelector, conversationIdByIndex, diff --git a/client/src/utils/thread.spec.ts b/client/src/utils/thread.spec.ts new file mode 100644 index 0000000000..0ccbe701d3 --- /dev/null +++ b/client/src/utils/thread.spec.ts @@ -0,0 +1,156 @@ +import type { TFile, TMessage } from 'librechat-data-provider'; +import { + ROOT_KEY, + buildThreadIndex, + changedParentKeys, + reconcileSiblingIdx, + resolveThreadRows, +} from './thread'; + +const ROOT = '00000000-0000-0000-0000-000000000000'; + +function message(messageId: string, parentMessageId: string, text = messageId): TMessage { + return { + messageId, + parentMessageId, + conversationId: 'c', + text, + isCreatedByUser: messageId.startsWith('u'), + } as TMessage; +} + +/** u1 -> a1 -> u2 -> (a2-old, a2) ; a2 -> u3 */ +function fixture(): TMessage[] { + return [ + message('u1', ROOT), + message('a1', 'u1'), + message('u2', 'a1'), + message('a2-old', 'u2'), + message('a2', 'u2'), + message('u3', 'a2'), + ]; +} + +describe('buildThreadIndex', () => { + it('indexes children in array order and lists branch points', () => { + const index = buildThreadIndex(fixture()); + expect(index.children.get(ROOT_KEY)).toEqual(['u1']); + expect(index.children.get('u2')).toEqual(['a2-old', 'a2']); + expect(index.branchParentKeys).toEqual(['u2']); + }); + + it('is memoized per array identity', () => { + const messages = fixture(); + expect(buildThreadIndex(messages)).toBe(buildThreadIndex(messages)); + expect(buildThreadIndex(messages)).not.toBe(buildThreadIndex(messages.slice())); + }); + + it('links a child that precedes its parent and roots an orphan', () => { + const index = buildThreadIndex([ + message('a1', 'u1'), + message('u1', ROOT), + message('x', 'gone'), + ]); + expect(index.children.get('u1')).toEqual(['a1']); + expect(index.children.get(ROOT_KEY)).toEqual(['u1', 'x']); + }); + + it('breaks a parent cycle by resurfacing it as a root', () => { + const index = buildThreadIndex([message('p', 'q'), message('q', 'p')]); + expect(index.children.get(ROOT_KEY)).toEqual(['p']); + expect(index.children.get('p')).toEqual(['q']); + expect(index.children.get('q')).toEqual([]); + const rows = resolveThreadRows(index, 'c', () => 0, null); + expect(rows.map((row) => row.source.messageId)).toEqual(['p', 'q']); + }); +}); + +describe('resolveThreadRows', () => { + it('follows the newest sibling by default and reports tree fields', () => { + const rows = resolveThreadRows(buildThreadIndex(fixture()), 'c', () => 0, null); + expect(rows.map((row) => row.source.messageId)).toEqual(['u1', 'a1', 'u2', 'a2', 'u3']); + expect(rows[3]).toMatchObject({ siblingIdx: 0, siblingCount: 2, depth: 3, childCount: 1 }); + expect(rows[3].message.depth).toBe(3); + expect(rows[3].message.children?.length).toBe(1); + expect(rows[2].parentKey).toBe('a1'); + expect(rows[0].parentKey).toBe('c'); + }); + + it('switches a branch through the selection lookup', () => { + const rows = resolveThreadRows( + buildThreadIndex(fixture()), + 'c', + (key) => (key === 'u2' ? 1 : 0), + null, + ); + expect(rows.map((row) => row.source.messageId)).toEqual(['u1', 'a1', 'u2', 'a2-old']); + }); + + it('reuses every untouched row across a streaming write and keeps the array when nothing changed', () => { + const first = fixture(); + const index = buildThreadIndex(first); + const rows = resolveThreadRows(index, 'c', () => 0, null); + const streamed = first.map((m) => (m.messageId === 'u3' ? { ...m, text: 'u3 more' } : m)); + const next = resolveThreadRows(buildThreadIndex(streamed), 'c', () => 0, rows); + expect(next).not.toBe(rows); + expect(next.slice(0, 4)).toEqual(rows.slice(0, 4)); + expect(next[0]).toBe(rows[0]); + expect(next[4]).not.toBe(rows[4]); + expect(next[4].message.text).toBe('u3 more'); + const again = resolveThreadRows(buildThreadIndex(streamed.slice()), 'c', () => 0, next); + expect(again).toBe(next); + }); +}); + +describe('resolveThreadRows with a file map', () => { + it('hydrates files on the row while reusing the raw cache identity', () => { + const withFile = { ...message('u1', ROOT), files: [{ file_id: 'f1' }] } as TMessage; + const fileMap: Record = { + f1: { file_id: 'f1', filename: 'hydrated.txt' } as TFile, + }; + const first = [withFile, message('a1', 'u1')]; + const rows = resolveThreadRows(buildThreadIndex(first, fileMap), 'c', () => 0, null); + expect(rows[0].source).toBe(withFile); + expect(rows[0].message.files?.[0]).toMatchObject({ filename: 'hydrated.txt' }); + const streamed = first.map((m) => (m.messageId === 'a1' ? { ...m, text: 'more' } : m)); + const next = resolveThreadRows(buildThreadIndex(streamed, fileMap), 'c', () => 0, rows); + expect(next[0]).toBe(rows[0]); + const remapped = resolveThreadRows( + buildThreadIndex(streamed, { ...fileMap }), + 'c', + () => 0, + next, + ); + expect(remapped[0]).not.toBe(next[0]); + }); +}); + +describe('reconcileSiblingIdx', () => { + it('follows an appended newest sibling', () => { + expect(reconcileSiblingIdx(['a', 'b'], ['a', 'b', 'c'], 1)).toBe(0); + expect(reconcileSiblingIdx(['a', 'b'], ['a', 'b', 'c'], 0)).toBeNull(); + }); + + it('keeps the viewed sibling through a re-key or reorder', () => { + expect(reconcileSiblingIdx(['a', 'b', 'c'], ['a', 'b', 'c2'], 1)).toBeNull(); + expect(reconcileSiblingIdx(['a', 'b', 'c'], ['b', 'a', 'c'], 2)).toBe(1); + }); + + it('falls back to the newest when the viewed sibling vanished', () => { + expect(reconcileSiblingIdx(['a', 'b', 'c'], ['b', 'c'], 2)).toBe(0); + }); + + it('clamps a stale index on a parent it has not seen', () => { + expect(reconcileSiblingIdx(undefined, ['a'], 3)).toBe(0); + expect(reconcileSiblingIdx(undefined, ['a', 'b'], 1)).toBeNull(); + }); +}); + +describe('changedParentKeys', () => { + it('reports only parents whose children list changed', () => { + const before = buildThreadIndex(fixture()); + const after = buildThreadIndex([...fixture(), message('a3', 'u3')]); + expect(changedParentKeys(before, after)).toEqual(['u3']); + expect(changedParentKeys(null, before).length).toBe(before.children.size); + }); +}); diff --git a/client/src/utils/thread.ts b/client/src/utils/thread.ts new file mode 100644 index 0000000000..1a53d2c33c --- /dev/null +++ b/client/src/utils/thread.ts @@ -0,0 +1,333 @@ +import type { TFile, TMessage } from 'librechat-data-provider'; + +/** Parent key under which parentless (and self-parented) messages are filed. */ +export const ROOT_KEY = ''; + +/** + * Keyed view of the flat messages array. Nodes reference the cached message + * objects themselves (no per-message copies), so an untouched message keeps + * its identity across streaming writes and memoized rows can bail on a + * reference check instead of a field diff. + */ +export type ThreadIndex = { + /** Raw cache objects: the identity rows are reused by. */ + messages: Map; + /** parent key -> child ids in creation (array) order */ + children: Map; + /** Parent keys with more than one child: the only levels whose selection matters. */ + branchParentKeys: string[]; + /** Applied to `files` when a row is built, so a hydrated copy never replaces the raw identity. */ + fileMap?: Record; +}; + +/** One visible row of the thread: the active path from root to leaf. */ +export type ThreadRow = { + /** Cache identity of the message, for reuse checks. */ + source: TMessage; + /** `source` with files hydrated and widened with the tree fields the row components read. */ + message: TMessage; + /** The file map `message` was hydrated with; a new map rebuilds the row. */ + fileMap?: Record; + /** Sibling-selection key: parent message id, or the root key for top-level rows. */ + parentKey: string; + depth: number; + /** Reversed sibling index (0 = newest), matching the selection atoms. */ + siblingIdx: number; + siblingCount: number; + childCount: number; +}; + +type IndexCacheEntry = { + bare?: ThreadIndex; + fileMap?: Record; + hydrated?: ThreadIndex; +}; + +const indexCache = new WeakMap<(TMessage | undefined)[], IndexCacheEntry>(); + +const NO_CHILDREN: TMessage[] = []; + +function hydrateFiles(message: TMessage, fileMap?: Record): TMessage { + if (!message.files || !fileMap) { + return message; + } + return { + ...message, + files: message.files.map((file) => fileMap[file.file_id ?? ''] ?? file), + }; +} + +function parentKeyOf(message: TMessage): string { + const parentId = message.parentMessageId; + if (parentId == null || parentId === message.messageId) { + return ROOT_KEY; + } + return parentId; +} + +/** + * Order-robust like `buildTree`: linking happens after every message is + * indexed, a message whose parent is absent becomes a root, and nodes on a + * corrupt parent cycle (unreachable from any root) resurface as roots. + */ +function indexMessages( + messages: (TMessage | undefined)[], + fileMap?: Record, +): ThreadIndex { + const byId = new Map(); + const ordered: TMessage[] = []; + for (const message of messages) { + if (!message) { + continue; + } + byId.set(message.messageId, message); + ordered.push(message); + } + + const children = new Map(); + const link = (parentKey: string, id: string) => { + const list = children.get(parentKey); + if (list) { + list.push(id); + return; + } + children.set(parentKey, [id]); + }; + for (const message of ordered) { + const parentKey = parentKeyOf(message); + link(parentKey !== ROOT_KEY && byId.has(parentKey) ? parentKey : ROOT_KEY, message.messageId); + } + + /** Every node has one parent, so a roots-down walk reaches each node once; + * an already-visited child is a cycle back-edge and is severed so path + * resolution terminates. */ + const visited = new Set(); + const walk = (startIds: string[]) => { + const stack = [...startIds]; + while (stack.length > 0) { + const id = stack.pop() as string; + if (visited.has(id)) { + continue; + } + visited.add(id); + const kids = children.get(id); + if (!kids) { + continue; + } + const reachable = kids.filter((kid) => !visited.has(kid)); + if (reachable.length !== kids.length) { + children.set(id, reachable); + } + for (let i = reachable.length - 1; i >= 0; i -= 1) { + stack.push(reachable[i]); + } + } + }; + walk(children.get(ROOT_KEY) ?? []); + if (visited.size !== ordered.length) { + for (const message of ordered) { + if (!visited.has(message.messageId)) { + link(ROOT_KEY, message.messageId); + walk([message.messageId]); + } + } + } + + const branchParentKeys: string[] = []; + for (const [parentKey, ids] of children) { + if (ids.length > 1) { + branchParentKeys.push(parentKey); + } + } + return { messages: byId, children, branchParentKeys, fileMap }; +} + +/** Memoized per messages-array identity, with one extra slot for the latest fileMap. */ +export function buildThreadIndex( + messages: (TMessage | undefined)[], + fileMap?: Record, +): ThreadIndex { + const cached = indexCache.get(messages); + if (cached) { + if (fileMap == null && cached.bare) { + return cached.bare; + } + if (fileMap != null && cached.fileMap === fileMap && cached.hydrated) { + return cached.hydrated; + } + } + const index = indexMessages(messages, fileMap); + const entry = cached ?? {}; + if (fileMap == null) { + entry.bare = index; + } else { + entry.fileMap = fileMap; + entry.hydrated = index; + } + indexCache.set(messages, entry); + return index; +} + +export type SiblingIndexLookup = (parentKey: string) => number; + +function clampSiblingIdx(siblingIdx: number, siblingCount: number): number { + return siblingIdx >= 0 && siblingIdx < siblingCount ? siblingIdx : 0; +} + +function rowsEqual( + previous: ThreadRow, + index: ThreadIndex, + source: TMessage, + depth: number, + siblingIdx: number, + siblingCount: number, + childCount: number, +): boolean { + return ( + previous.source === source && + previous.fileMap === index.fileMap && + previous.depth === depth && + previous.siblingIdx === siblingIdx && + previous.siblingCount === siblingCount && + previous.childCount === childCount + ); +} + +/** + * Walks the active branch (root -> leaf) following the per-level sibling + * selection, O(depth). Rows whose inputs are unchanged are reused from + * `previousRows` so memoized row components bail by reference; when every + * row is reused, `previousRows` itself is returned. + * + * `rootKey` is the selection key of the top level (the conversation id), the + * same key the sibling atoms have always used for root siblings. + */ +export function resolveThreadRows( + index: ThreadIndex, + rootKey: string, + getSiblingIdx: SiblingIndexLookup, + previousRows: ThreadRow[] | null, +): ThreadRow[] { + const previousById = new Map(); + if (previousRows) { + for (const row of previousRows) { + previousById.set(row.source.messageId, row); + } + } + + const rows: ThreadRow[] = []; + let reusedAll = previousRows != null; + let siblings = index.children.get(ROOT_KEY) ?? []; + let parentKey = rootKey; + let atomKey = rootKey; + let depth = 0; + + while (siblings.length > 0) { + const siblingCount = siblings.length; + const siblingIdx = clampSiblingIdx(getSiblingIdx(atomKey), siblingCount); + const id = siblings[siblingCount - siblingIdx - 1]; + const source = index.messages.get(id); + if (!source) { + break; + } + const childIds = index.children.get(id) ?? []; + const childCount = childIds.length; + const previous = previousById.get(id); + if ( + previous && + rowsEqual(previous, index, source, depth, siblingIdx, siblingCount, childCount) + ) { + rows.push(previous); + } else { + reusedAll = false; + const children = + childCount === 0 + ? NO_CHILDREN + : childIds + .map((childId) => index.messages.get(childId)) + .filter((child): child is TMessage => child != null); + rows.push({ + source, + message: { ...hydrateFiles(source, index.fileMap), depth, children }, + fileMap: index.fileMap, + parentKey, + depth, + siblingIdx, + siblingCount, + childCount, + }); + } + parentKey = id; + atomKey = id; + siblings = childIds; + depth += 1; + } + + if (reusedAll && previousRows && previousRows.length === rows.length) { + return previousRows; + } + return rows; +} + +/** + * Sibling-selection reconciliation for one level, ported from the recursive + * `MultiMessage` effect: an APPENDED newest child is followed (send, regenerate + * and edit-resubmit all append); any other change to the children list keeps + * the message the user was viewing, recomputing its reversed index, and falls + * back to the newest only when it no longer exists. Returns the next reversed + * index, or `null` when the current one stands. + */ +export function reconcileSiblingIdx( + previousIds: string[] | undefined, + nextIds: string[], + currentIdx: number, +): number | null { + const length = nextIds.length; + if (length === 0) { + return null; + } + if (!previousIds) { + return currentIdx >= length ? 0 : null; + } + const newestId = nextIds[length - 1]; + const previousNewestId = previousIds[previousIds.length - 1]; + const appendedNewest = + previousNewestId == null || + (newestId !== previousNewestId && + !previousIds.includes(newestId) && + nextIds.includes(previousNewestId)); + let nextIdx = currentIdx; + if (appendedNewest) { + nextIdx = 0; + } else if (currentIdx > 0) { + const viewedId = previousIds[previousIds.length - currentIdx - 1]; + const viewedIndex = viewedId == null ? -1 : nextIds.indexOf(viewedId); + nextIdx = viewedIndex >= 0 ? length - viewedIndex - 1 : 0; + } else if (currentIdx >= length) { + nextIdx = 0; + } + return nextIdx === currentIdx ? null : nextIdx; +} + +function sameIds(a: string[] | undefined, b: string[]): boolean { + if (!a || a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i += 1) { + if (a[i] !== b[i]) { + return false; + } + } + return true; +} + +/** Index keys whose children list changed between two indexes. */ +export function changedParentKeys(previous: ThreadIndex | null, next: ThreadIndex): string[] { + const changed: string[] = []; + for (const [key, ids] of next.children) { + if (!sameIds(previous?.children.get(key), ids)) { + changed.push(key); + } + } + return changed; +} diff --git a/client/src/vite-env.d.ts b/client/src/vite-env.d.ts index a7feb04700..9ff196fed7 100644 --- a/client/src/vite-env.d.ts +++ b/client/src/vite-env.d.ts @@ -3,6 +3,7 @@ interface ImportMetaEnv { readonly VITE_ENABLE_LOGGER: string; readonly VITE_LOGGER_FILTER: string; + readonly VITE_FLAT_THREAD: string; // Add other env variables here } diff --git a/e2e/benchmarks-tree/flatenv.ts b/e2e/benchmarks-tree/flatenv.ts new file mode 100644 index 0000000000..dcbd247b3b --- /dev/null +++ b/e2e/benchmarks-tree/flatenv.ts @@ -0,0 +1,2 @@ +/** Side-effect module: defaults the flat thread renderer ON for the parity config. */ +process.env.VITE_FLAT_THREAD = process.env.VITE_FLAT_THREAD ?? 'true'; diff --git a/e2e/benchmarks-tree/payload.ts b/e2e/benchmarks-tree/payload.ts new file mode 100644 index 0000000000..0f266a38fc --- /dev/null +++ b/e2e/benchmarks-tree/payload.ts @@ -0,0 +1,99 @@ +import type { SeedMessage } from '../specs/mock/db'; + +/** + * Deterministic transcript for the message-tree render benchmark: a long + * linear spine with two regenerate branches, one shallow (short alternate + * continuation) and one at the leaf, so both a deep path swap and a + * leaf-only sibling switch can be measured against the same thread. + */ +/** Turns per seeded thread; `TREE_PERF_TURNS` overrides it for scaling runs. */ +export const TURNS = Number(process.env.TREE_PERF_TURNS) || 120; +export const ROWS = TURNS * 2; +export const SHALLOW_BRANCH_TURN = 3; +export const SHALLOW_BRANCH_CONTINUATION_TURNS = 2; +export const ROOT_PARENT = '00000000-0000-0000-0000-000000000000'; + +const SENTENCE = + 'The rollout plan sequences every dependent service behind a single feature flag so rollbacks stay one toggle away. '; + +export function marker(label: string): string { + return `TREEBENCH-${label}`; +} + +export function turnHeading(label: string, turn: number): string { + return `${marker(label)} section ${turn}`; +} + +export function altHeading(label: string, turn: number): string { + return `${marker(label)} alternate ${turn}`; +} + +function assistantBody(heading: string, turn: number): string { + let body = `## ${heading}\n\n${SENTENCE}${SENTENCE}\n\n`; + body += `- ${marker('point')} one for turn ${turn}\n`; + body += `- ${marker('point')} two for turn ${turn}\n\n`; + if (turn % 3 === 0) { + body += + '```ts\nexport function rollout(stage: number): boolean {\n return stage > 0;\n}\n```\n\n'; + } + if (turn % 4 === 0) { + body += '| Service | Requests |\n| --- | --- |\n| gateway | 120000 |\n| worker | 135500 |\n\n'; + } + return body; +} + +function userRow(label: string, id: string, parentMessageId: string, turn: number): SeedMessage { + return { + messageId: id, + parentMessageId, + text: `${marker(label)} prompt ${turn}: walk me through the rollout for stage ${turn}.`, + isCreatedByUser: true, + sender: 'User', + }; +} + +function assistantRow(id: string, parentMessageId: string, heading: string, turn: number) { + return { + messageId: id, + parentMessageId, + text: assistantBody(heading, turn), + isCreatedByUser: false, + sender: 'Assistant', + }; +} + +/** + * Seed order doubles as creation order, so an alternate sibling is emitted + * BEFORE the spine row it competes with: the newest sibling is the default + * selection, and the spine must stay the default visible path. + */ +export function buildTreeMessages(label: string): SeedMessage[] { + const messages: SeedMessage[] = []; + let parentMessageId = ROOT_PARENT; + for (let turn = 1; turn <= TURNS; turn += 1) { + const userId = `${label}-user-${turn}`; + messages.push(userRow(label, userId, parentMessageId, turn)); + const assistantId = `${label}-assistant-${turn}`; + if (turn === SHALLOW_BRANCH_TURN) { + const altId = `${label}-assistant-${turn}-alt`; + messages.push(assistantRow(altId, userId, altHeading(label, turn), turn)); + let altParent = altId; + for (let extra = 1; extra <= SHALLOW_BRANCH_CONTINUATION_TURNS; extra += 1) { + const altTurn = 1000 + extra; + const altUser = `${label}-alt-user-${extra}`; + messages.push(userRow(label, altUser, altParent, altTurn)); + const altAssistant = `${label}-alt-assistant-${extra}`; + messages.push(assistantRow(altAssistant, altUser, altHeading(label, altTurn), altTurn)); + altParent = altAssistant; + } + } + if (turn === TURNS) { + messages.push( + assistantRow(`${label}-assistant-${turn}-alt`, userId, altHeading(label, turn), turn), + ); + } + messages.push(assistantRow(assistantId, userId, turnHeading(label, turn), turn)); + parentMessageId = assistantId; + } + return messages; +} diff --git a/e2e/benchmarks-tree/tree-render.perf.spec.ts b/e2e/benchmarks-tree/tree-render.perf.spec.ts new file mode 100644 index 0000000000..701227156f --- /dev/null +++ b/e2e/benchmarks-tree/tree-render.perf.spec.ts @@ -0,0 +1,383 @@ +import { randomUUID } from 'node:crypto'; +import { expect, test } from '@playwright/test'; +import type { Page } from '@playwright/test'; +import type { BrowserPhase } from '../perf/browser'; +import type { PerfSnapshot } from '../perf/scan'; +import { createBrowserProbe, installBrowserPerf } from '../perf/browser'; +import { deleteConversations, deleteMessagesByConversation, withMongo } from '../specs/mock/db'; +import { MOCK_ENDPOINTS, messagesView, sendMessage } from '../specs/mock/helpers'; +import { getE2EUser } from '../setup/user'; +import { + attachSnapshot, + buildTallySetup, + installReactScan, + longTaskStats, + resetPerf, + snapshotPerf, + topComponents, + totals, +} from '../perf/scan'; +import { + ROWS, + SHALLOW_BRANCH_CONTINUATION_TURNS, + SHALLOW_BRANCH_TURN, + TURNS, + altHeading, + buildTreeMessages, + turnHeading, +} from './payload'; + +/** + * Message-tree render benchmark (react-scan). + * + * Measures what the tree-shaped render path costs on a long thread: renders + * and render time per streamed delta, and per sibling switch at the leaf and + * near the root. The numbers are printed and attached; the assertions only + * guard the harness itself. + */ + +const userEmail = getE2EUser().email; +/** `TREE_PERF_SCAN=0` drops react-scan so long-task totals carry no instrumentation overhead. */ +const WITH_SCAN = process.env.TREE_PERF_SCAN !== '0'; +const VARIANTS = [ + { name: 'tree (recursive MultiMessage)', flat: false, label: 'T' }, + { name: 'flat (index + path list)', flat: true, label: 'F' }, +] as const; +type Variant = (typeof VARIANTS)[number]; +const CONVOS = new Map( + VARIANTS.map((variant) => [ + variant.label, + { id: randomUUID(), label: variant.label, title: `Tree render bench ${variant.label}` }, + ]), +); +const ENDPOINT = MOCK_ENDPOINTS[0]; +const KEY_COMPONENTS = [ + 'MultiMessage', + 'MessageRender', + 'ContentRender', + 'Message', + 'MessageContent', + 'MarkdownBlock', + 'SiblingSwitch', + 'MessagesViewContent', +]; + +async function seedTree(CONVO: { id: string; label: string; title: string }): Promise { + await withMongo(async (db) => { + const user = await db.collection('users').findOne({ email: userEmail }); + if (!user) { + throw new Error(`E2E 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() - ROWS * 2000; + const docs = buildTreeMessages(CONVO.label).map((message, index) => ({ + ...message, + 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); + }); +} + +function heading(page: Page, text: string) { + return messagesView(page).getByRole('heading', { name: text, exact: true }).first(); +} + +type ResourceSample = { + heapMB: number; + heapTotalMB: number; + nodes: number; + listeners: number; + rendererCpuS: number; +}; + +/** + * Process-level cost per phase: JS heap after a forced GC (retained memory, + * not allocation churn), DOM node and listener counts, and the renderer + * process CPU time consumed during the phase (all threads, so compositor and + * GC work count, which the main-thread task total above leaves out). + */ +async function createResourceProbe(page: Page) { + const session = await page.context().newCDPSession(page); + await session.send('HeapProfiler.enable'); + await session.send('Performance.enable'); + const browser = page.context().browser(); + const browserSession = browser ? await browser.newBrowserCDPSession() : null; + const rendererCpu = async () => { + if (!browserSession) { + return 0; + } + const { processInfo } = await browserSession.send('SystemInfo.getProcessInfo'); + return processInfo + .filter((info) => info.type === 'renderer') + .reduce((sum, info) => sum + info.cpuTime, 0); + }; + let cpuStart = 0; + return { + async start() { + cpuStart = await rendererCpu(); + }, + async sample(): Promise { + const cpuEnd = await rendererCpu(); + await session.send('HeapProfiler.collectGarbage'); + const { metrics } = await session.send('Performance.getMetrics'); + const metric = (name: string) => metrics.find((entry) => entry.name === name)?.value ?? 0; + return { + heapMB: metric('JSHeapUsedSize') / 1048576, + heapTotalMB: metric('JSHeapTotalSize') / 1048576, + nodes: metric('Nodes'), + listeners: metric('JSEventListeners'), + rendererCpuS: cpuEnd - cpuStart, + }; + }, + }; +} + +function report( + name: string, + snapshot: PerfSnapshot, + browser: BrowserPhase, + extra: Record = {}, + resources?: ResourceSample, +) { + const sum = totals(snapshot); + const tasks = longTaskStats(snapshot); + console.log(`\n=== ${name} (${Math.ceil(snapshot.elapsedMs)}ms wall) ===`); + console.log( + `total renders=${sum.renders} render-time=${sum.time.toFixed(0)}ms ` + + `longtask-total=${tasks.total.toFixed(0)}ms worst-longtask=${tasks.worst.toFixed(0)}ms`, + ); + console.log( + `cdp: task=${browser.taskMs.toFixed(0)}ms script=${browser.scriptMs.toFixed(0)}ms ` + + `layout=${browser.layoutMs.toFixed(0)}ms style=${browser.styleMs.toFixed(0)}ms ` + + `busy=${browser.busyPercent.toFixed(1)}% layouts=${browser.layoutCount} ` + + `heap=${(browser.heapEndBytes / 1048576).toFixed(0)}MB nodes=${browser.nodesEnd}`, + ); + if (resources) { + console.log( + `resources: rendererCPU=${resources.rendererCpuS.toFixed(2)}s ` + + `heapAfterGC=${resources.heapMB.toFixed(1)}MB heapTotal=${resources.heapTotalMB.toFixed(0)}MB ` + + `nodes=${resources.nodes} listeners=${resources.listeners}`, + ); + } + for (const [key, value] of Object.entries(extra)) { + console.log(`${key}=${value}`); + } + console.log('key components:'); + for (const component of KEY_COMPONENTS) { + const slot = snapshot.renders[component]; + console.log( + ` ${component.padEnd(20)} renders=${String(slot?.count ?? 0).padStart(6)} time=${(slot?.time ?? 0).toFixed(1)}ms`, + ); + } + console.log('top components:'); + for (const line of topComponents(snapshot, 12)) { + console.log(` ${line}`); + } +} + +/** Rows the deep switch drops: the spine below the branch turn, less the alternate continuation. */ +const DEEP_SWITCH_ROWS = ROWS - SHALLOW_BRANCH_TURN * 2 - SHALLOW_BRANCH_CONTINUATION_TURNS * 2; + +async function clickSibling(page: Page, name: string, position: 'first' | 'last') { + const buttons = page.getByRole('button', { name, exact: true }); + const button = position === 'first' ? buttons.first() : buttons.last(); + await button.dispatchEvent('click'); +} + +test.describe('message tree render perf (react-scan)', () => { + test.beforeAll(async () => { + for (const convo of CONVOS.values()) { + await seedTree(convo); + } + }); + + test.afterAll(async () => { + const ids = Array.from(CONVOS.values()).map((convo) => convo.id); + await deleteMessagesByConversation(ids); + await deleteConversations(ids); + }); + + for (const variant of VARIANTS) { + test(`${variant.name}: streaming and sibling switches on a long thread`, async ({ + page, + }, testInfo) => { + await runVariant(page, testInfo, variant); + }); + } +}); + +async function runVariant( + page: Page, + testInfo: Parameters[1]>[1], + variant: Variant, +) { + const CONVO = CONVOS.get(variant.label); + if (!CONVO) { + throw new Error('variant conversation missing'); + } + { + test.setTimeout(8 * 60 * 1000); + if (WITH_SCAN) { + await installReactScan(page, 'MultiMessage'); + } else { + await page.addInitScript({ content: buildTallySetup('MultiMessage') }); + } + await installBrowserPerf(page); + const probe = await createBrowserProbe(page); + const resourceProbe = await createResourceProbe(page); + /** TTS mounts a src-less