LibreChat/e2e/benchmarks-fade
Danny Avila b3a2ba96a9
🪟 perf: Skip Thread Rows Far From the Viewport (#18201)
* 🪟 perf: Skip Thread Rows Far From the Viewport

Opening or closing the sidebar beside a long thread laid out and painted
every row of it on every frame of the 300 ms slide, because the slide
changes the chat pane's width. In a 246-row thread that was 17 ms of main
thread per frame, 55 ms on a CPU four times slower, where the slide ran at
about a dozen frames a second with tasks over 100 ms.

A row more than a screen from the thread's viewport is now skipped by the
browser (`content-visibility: auto`), so a change that touches the whole
thread costs only the rows near the reader. Rows within a screen are left
exactly as they were: none of them gains the clipping and containment that
skipping implies. A skipped row keeps the size it was last laid out at, so
the scrollbar, the navigation rail and the mount anchor see the same
thread, and it stays reachable by find-in-page, focus and anchors.

The skip sits on the row element the rail and the mount anchor measure:
reading the box of an element inside a skipped row makes the browser lay
that row out again. Screenshot export lays every row out before it clones
the thread, since a clone has no remembered size.

The navigation rail measured every row on each frame of a width change.
It now waits for the width to hold still and measures once; a height
change, which is what a streaming reply is, is still followed frame by
frame. Alone that saved nothing, because its reads forced a layout the
frame needed anyway; with rows skipped it is a fifth of what remains.

* 🧮 fix: Keep Rows Laid Out Until Every Overlapping Capture Is Done

`revealOffscreenRows` handed each caller the thread's `watch` function as
its resume. Two captures that overlap (a second screenshot export started
before the first finished) each got one: the first to finish resumed
skipping while the second was still cloning the thread, and the second
then created another observer without disconnecting the first, which no
cleanup released. A resume called after the thread had unmounted created
an observer for a thread that was gone.

Each thread now counts its outstanding reveals. Skipping resumes when the
last one is done, a resume counts once however often it is called, and
does nothing once the thread has unmounted.
2026-11-16 08:47:14 -05:00
..
chats.ts 🔇 fix: Stop Every Row's Read-Aloud Element From Loading the Page (#18168) 2026-11-14 15:02:16 -05:00
fade-frames.perf.spec.ts
README.md 🪟 perf: Skip Thread Rows Far From the Viewport (#18201) 2026-11-16 08:47:14 -05:00
replay.perf.spec.ts 🧵 perf: Stop Re-rendering and Re-styling the Thread on Stream Events and Run Boundaries (#18148) 2026-11-14 12:15:48 -05:00
replay.ts
restyle.perf.spec.ts 🧵 perf: Stop Re-rendering and Re-styling the Thread on Stream Events and Run Boundaries (#18148) 2026-11-14 12:15:48 -05:00
scroll.perf.spec.ts 🪟 perf: Skip Thread Rows Far From the Viewport (#18201) 2026-11-16 08:47:14 -05:00
sidebar.perf.spec.ts 🪟 perf: Skip Thread Rows Far From the Viewport (#18201) 2026-11-16 08:47:14 -05:00
speech.perf.spec.ts 🔇 fix: Stop Every Row's Read-Aloud Element From Loading the Page (#18168) 2026-11-14 15:02:16 -05:00
trace.ts 🧵 perf: Stop Re-rendering and Re-styling the Thread on Stream Events and Run Boundaries (#18148) 2026-11-14 12:15:48 -05:00
why.ts 🧵 perf: Stop Re-rendering and Re-styling the Thread on Stream Events and Run Boundaries (#18148) 2026-11-14 12:15:48 -05:00

Live-run frame and event cost

Measures what a live run costs the browser's main thread inside a long, real transcript, from a Chromium trace of the built client:

  • fade-frames.perf.spec.ts: the cost of a frame. Traces the open chat idle, then with one sweeping label (Shimmer) on screen, then through a short live run. An animation that stays on the compositor costs the main thread nothing; one that repaints shows up as hundreds of frames of Paint, and that paint grows with the transcript around the label.

  • replay.perf.spec.ts: the cost of each kind of stream event. Takes one assistant message from the chat, streams it back in at the tail of the same chat a frame at a time, and reports main-thread time per window by event kind: a tool call starting, its arguments, its result, a label filling, a reasoning or text delta, the final frame. idle windows carry no event and show what is left over from the events before them. Part way through, the replay holds the run still for three seconds and traces that on its own: with no event arriving, whatever the main thread does there it does for the run's animations.

  • speech.perf.spec.ts: the cost of the read-aloud control. Every assistant row carries a hidden <audio> element for it, which should load nothing until its button is pressed. The spec counts the media errors and media requests those elements make while the thread mounts and across two short runs, and traces the main thread for each. Anything above zero errors and one request (the composer's silent clip) is a row loading something it was not asked to.

  • sidebar.perf.spec.ts: the cost of opening and closing the sidebar beside the thread. The sidebar slides by changing its width, so the chat pane changes width on every frame of the slide; each direction is traced on its own. ms/frame and the longest task say whether the slide can hold a frame rate. FADE_PERF_PROFILE=1 adds the script's self time and FADE_PERF_WHY=1 the components that render for each toggle.

  • scroll.perf.spec.ts: the cost of reading back through the thread, a page at a time from the latest turn towards the first and back. Rows far from the viewport are skipped by the browser and laid out again as a scroll brings them near, so this is where that work shows up if it ever costs more than it saves.

  • restyle.perf.spec.ts: the cost of one small change in every row at once, which is what a run starting or ending is. It flips a class, flips disabled and mounts a button on each row by hand and times the style and layout pass that follows. With a stylesheet whose :has() rules name their subjects these are a few milliseconds per hundred rows; a single rule that does not multiplies them by ten.

The transcript is yours. Nothing synthetic stands in for it, because the point is a conversation of the size and shape a reader actually has: export one from the chat's Export action as JSON and pass its path.

Run

Requires a built client (client/dist) like the other mock e2e configs.

npm run frontend
FADE_PERF_CHATS=/path/to/export.json \
  npx playwright test --config=e2e/playwright.config.fade-perf.ts

FADE_PERF_CHATS takes several paths, comma-separated; each gets its own run. To compare two builds, run the same command on each and read the tables side by side.

Variable Effect
FADE_PERF_CPU Slows the renderer by this factor, as DevTools CPU throttling does.
FADE_PERF_THEME The color theme to open the chat in, such as dark.
FADE_PERF_TTS 0 turns read-aloud off, removing the per-row <audio> elements.
FADE_PERF_PROMPT The fake model's scripted reply for the live run.
FADE_PERF_CSS A stylesheet laid over the shipped one, to try a remedy.
FADE_PERF_SKIP_LIVE 1 stops the frame spec after the idle and label traces.
FADE_PERF_PROFILE 1 samples the page's JavaScript: a second live run, or the replay.
FADE_PERF_DUMP A directory that receives raw traces, profiles and replay windows.
FADE_PERF_CATEGORIES More trace categories for a dump, comma-separated.
FADE_PERF_REPLAY_INDEX Which message to replay (position in the flattened export).
FADE_PERF_REPLAY_PARTS Replays only the first N content parts.
FADE_PERF_GAP_MS Pause after each replayed frame; 150 by default.
FADE_PERF_ANIMATIONS 1 lists what is animating during the replay, and which properties.
FADE_PERF_WHY 1 counts component renders across the replay, with their causes.
FADE_PERF_WHY_LIMIT How many components that count lists; 80 by default.

Reading the output

busy is main-thread time over wall time; frames counts the frames the main thread produced. A page at rest produces a handful. A label whose animation runs on the main thread produces one per display refresh.

In the replay tables every column is the median over that kind's windows, in milliseconds of main-thread time per window, split by self time: a layout forced from script counts as layout. worst is the longest single task seen for the kind. Subtract the idle row to get what an event adds.

The replay also times the turn's two ends as windows of their own: send is the keypress that publishes the turn, created the frame that confirms it, and final the frame that closes the run. Each of those changes every row's toolbar, so they are where a long thread shows its long tasks.

FADE_PERF_WHY=1 swaps the trace for a render count: for the send, the events and the final frame, each component that rendered, how many times, and why (a prop that changed identity, a state or store hook of its own, query data it selects, a context it reads, or only its parent). It runs on the production bundle and names components by the source map when the build wrote one, else by where the function sits in its chunk. A component that renders once per event with nothing to show for it is the thing to look for.

When a window shows a long layout or style pass with almost nothing dirty, dump the trace with FADE_PERF_CATEGORIES=disabled-by-default-devtools.timeline.invalidationTracking and read the StyleInvalidatorInvalidationTracking events before it: they name the nodes whose subtrees were invalidated and the selector feature that did it. That is how a disabled flip on one button per row turned out to re-style every row of the thread, through the stylesheet's :has(:disabled) rules.

To compare with and without skipped rows on one build, lay this over the page with FADE_PERF_CSS; the rows are still marked, but every one is laid out and painted:

.message-render[data-offscreen] {
  content-visibility: visible !important;
}

Role locators are kept out of the measured windows: Playwright computes accessible names across the whole transcript on each poll, which a trace records as the page's own work.