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