Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🌿 feat: Branch Tool Fold Rails Into Each Row (#17407)
Marco Beretta229303c669c2
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsxindex 5f749d5824..d385e2895d 100644--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx@@ -217,7 +217,7 @@ const event = (});describe('SubagentCall', () => {- it('registers its existing header glyph for both containing fold rails', () => {+ it('registers its existing header glyph as a branch of its fold', () => {renderWithState({ toolCallId: 'fold-glyph', initialProgress: 1 });const row = screen.getByRole('button', { name: 'Ran agent' }).cloneNode(true) as HTMLElement;const glyph = row.querySelector<HTMLElement>(FOLD_GLYPH_SELECTOR);@@ -240,10 +240,8 @@ describe('SubagentCall', () => {rails.push(rail);}parent.append(row);- expect(litFoldPath(root, row, 155)).toEqual([- { rail: rails[1], length: 54, end: true },- { rail: rails[0], length: 118, end: false },- ]);+ /** The outer fold holds no row of its own above this one, so it has no branch to light. */+ expect(litFoldPath(root, row, 155)).toEqual([{ rail: rails[1], branch: 0 }]);});it('keeps the configured name and avatar after live progress is cleared', () => {diff --git a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsxindex 2ad264861d..98694e9033 100644--- a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx@@ -2538,7 +2538,7 @@ describe('ContentParts — live activity fold', () => {});describe('fold paths in parallel columns', () => {- it('marks real lane boundaries and selects the header owning each output', () => {+ it('marks real lane boundaries and keeps lane rows off the fold trunk', () => {const { container } = render(<div data-fold-root=""><div data-fold-panel="">@@ -2576,12 +2576,9 @@ describe('fold paths in parallel columns', () => {({ top: 300, height: 20 }) as DOMRect;screen.getByTestId('lane-glyph-1').getBoundingClientRect = () =>({ top: 50, height: 20 }) as DOMRect;+ /** Lane rows are not branches of the fold, which keeps its trunk dark over them. */const cache = new WeakMap<Element, Element[]>();- expect(litFoldPath(root, screen.getByTestId('lane-output-0'), 350, cache)).toEqual([- { rail, length: 268, end: true },- ]);- expect(litFoldPath(root, screen.getByTestId('lane-output-1'), 350, cache)).toEqual([- { rail, length: 18, end: true },- ]);+ expect(litFoldPath(root, screen.getByTestId('lane-output-0'), 350, cache)).toEqual([]);+ expect(litFoldPath(root, screen.getByTestId('lane-output-1'), 350, cache)).toEqual([]);});});diff --git a/client/src/components/Chat/Messages/Content/__tests__/rail.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/rail.test.tsxindex 0b10ff77b2..a892725b2e 100644--- a/client/src/components/Chat/Messages/Content/__tests__/rail.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/rail.test.tsx@@ -1,5 +1,5 @@import React from 'react';-import { render, renderHook, screen, fireEvent } from '@testing-library/react';+import { act, render, renderHook, screen, fireEvent } from '@testing-library/react';import {FoldRail,RailGlyph,@@ -194,38 +194,32 @@ describe('litFoldPath', () => {document.body.innerHTML = '';});- it('lights every fold that holds the row, innermost first, down to its center', () => {+ it('lights every fold that holds the row, innermost first, each into its own branch', () => {const { root, a, b, rows } = foldFixture();expect(litFoldPath(root, rows.b2, 150)).toEqual([- { rail: b.rail, length: 156 - 104 - 2, end: true },- { rail: a.rail, length: 156 - 40 - 2, end: false },+ { rail: b.rail, branch: 1 },+ { rail: a.rail, branch: 1 },]);});it('ends a nested header at the fold that holds it', () => {const { root, a, rows } = foldFixture();- expect(litFoldPath(root, rows.header, 90)).toEqual([- { rail: a.rail, length: 92 - 40 - 2, end: true },- ]);+ expect(litFoldPath(root, rows.header, 90)).toEqual([{ rail: a.rail, branch: 1 }]);});it('counts the margin above a glyph as that row', () => {const { root, b, rows } = foldFixture();- expect(litFoldPath(root, rows.b2, 141)[0]).toEqual({ rail: b.rail, length: 50, end: true });+ expect(litFoldPath(root, rows.b2, 141)[0]).toEqual({ rail: b.rail, branch: 1 });});it('points at the row above when the pointer is inside an open body', () => {const { root, b } = foldFixture();const body = document.createElement('pre');b.el.append(body);- expect(litFoldPath(root, body, 205)[0]).toEqual({- rail: b.rail,- length: 188 - 104 - 2,- end: true,- });+ expect(litFoldPath(root, body, 205)[0]).toEqual({ rail: b.rail, branch: 2 });});- it('searches only the hovered column when document order is not vertical order', () => {+ it('leaves rows in parallel columns without a branch to light', () => {const { root, a, rows } = foldFixture();const left = document.createElement('div');const right = document.createElement('div');@@ -237,15 +231,13 @@ describe('litFoldPath', () => {const body = document.createElement('pre');left.append(body);const cache = new WeakMap<Element, Element[]>();- expect(litFoldPath(root, rows.a2, 225, cache)).toEqual([- { rail: a.rail, length: 188, end: true },- ]);- expect(litFoldPath(root, body, 260, cache)[0].length).toBe(188);- expect(litFoldPath(root, rows.header, 90, cache)[0].length).toBe(50);+ expect(litFoldPath(root, rows.a2, 225, cache)).toEqual([]);+ expect(litFoldPath(root, body, 260, cache)).toEqual([]);+ expect(litFoldPath(root, rows.header, 90, cache)).toEqual([]);expect(litFoldPath(root, a.el, 225, cache)).toEqual([]);});- it('excludes nested columns but keeps a nested panel in its surrounding column', () => {+ it('still lights a nested panel that sits in a column of its parent', () => {const { root, a, b, rows } = foldFixture();const column = document.createElement('div');const nested = document.createElement('div');@@ -254,12 +246,9 @@ describe('litFoldPath', () => {nested.append(rows.b1);column.append(rows.a1, rows.a2, nested, b.el);a.el.replaceChildren(a.rail, column);- expect(litFoldPath(root, rows.a2, 225)[0].length).toBe(188);- expect(litFoldPath(root, rows.b1, 120)[0].length).toBe(82);- expect(litFoldPath(root, rows.b2, 150)).toEqual([- { rail: b.rail, length: 50, end: true },- { rail: a.rail, length: 114, end: false },- ]);+ expect(litFoldPath(root, rows.a2, 225)).toEqual([]);+ expect(litFoldPath(root, rows.b1, 120)).toEqual([]);+ expect(litFoldPath(root, rows.b2, 150)).toEqual([{ rail: b.rail, branch: 0 }]);});it('leaves the rails and the outermost header alone', () => {@@ -272,6 +261,8 @@ describe('litFoldPath', () => {describe('useFoldPath', () => {let frames: FrameRequestCallback[] = [];let resize: ResizeObserverCallback;+ /** What sits under the pointer when a layout change has the hook hit-test again. */+ const hit = jest.fn<Element | null, [number, number]>(() => null);const observe = jest.fn();const disconnect = jest.fn();const flushFrames = () => {@@ -308,34 +299,148 @@ describe('useFoldPath', () => {jest.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {frames = [];});+ hit.mockReset().mockReturnValue(null);+ Object.defineProperty(document, 'elementFromPoint', { configurable: true, value: hit });});afterEach(() => {jest.restoreAllMocks();+ Reflect.deleteProperty(document, 'elementFromPoint');+ window.matchMedia = allMotion;document.body.innerHTML = '';});+ /** Gives each fixture rail the lit path and the row centers `FoldRail` renders. */+ const traced = (rail: HTMLElement, centers: number[]) => {+ rail.dataset.centers = centers.join(',');+ const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');+ path.setAttribute('data-fold-trace', '');+ rail.append(path);+ return path;+ };+ /** The setup's `matchMedia` is already a mock, so swap it rather than spy on it. */+ const allMotion = window.matchMedia;+ const reduceMotion = () => {+ window.matchMedia = ((query: string) =>+ ({+ matches: query.includes('reduce'),+ media: query,+ }) as MediaQueryList) as typeof window.matchMedia;+ };+it('paints the path onto the rails and clears it when the pointer leaves', () => {+ reduceMotion();const { root, a, b, rows } = foldFixture();+ /** Centers relative to each rail's top. */+ const bPath = traced(b.rail, [20, 52, 84]);+ const aPath = traced(a.rail, [20, 52, 190]);const { unmount } = renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b2, 150);- expect(b.rail.dataset.foldLit).toBe('end');- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('50px');- expect(a.rail.dataset.foldLit).toBe('through');- expect(a.rail.style.getPropertyValue('--fold-lit')).toBe('114px');+ expect(b.rail.dataset.foldLit).toBe('1');+ expect(a.rail.dataset.foldLit).toBe('1');+ expect(bPath).toHaveAttribute('data-lit');+ expect(bPath).toHaveAttribute('d', 'M 11.5 2 V 44 A 8 8 0 0 0 19.5 52 H 22');+ expect(aPath).toHaveAttribute('d', 'M 11.5 2 V 44 A 8 8 0 0 0 19.5 52 H 22');pointer('pointermove', rows.a2, 225);expect(b.rail.dataset.foldLit).toBeUndefined();- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('');- expect(a.rail.dataset.foldLit).toBe('end');+ expect(bPath).not.toHaveAttribute('data-lit');+ expect(a.rail.dataset.foldLit).toBe('2');+ expect(aPath).toHaveAttribute('d', 'M 11.5 2 V 182 A 8 8 0 0 0 19.5 190 H 22');pointer('pointerleave', root, 0);expect(a.rail.dataset.foldLit).toBeUndefined();+ expect(aPath).not.toHaveAttribute('data-lit');unmount();});- it('follows no touch, and drops the path on a press that may move the rows', () => {+ it('travels the tree from one row to the next: out of the branch, along the trunk, in', () => {+ const { root, b, rows } = foldFixture();+ const path = traced(b.rail, [20, 52, 84]);+ renderHook(() => useFoldPath({ current: root }, true));+ const shape = () => {+ const d = path.getAttribute('d') ?? '';+ return { d, tip: Number(/V ([\d.]+)/.exec(d)?.[1]), branch: d.includes(' A ') };+ };+ const frameAt = (now: number) => {+ const pending = frames;+ frames = [];+ pending.forEach((callback) => callback(now));+ };++ pointer('pointermove', rows.b3, 180, 'mouse', false);+ frameAt(0);+ frameAt(0);+ frameAt(1000);+ expect(path).toHaveAttribute('d', 'M 11.5 2 V 76 A 8 8 0 0 0 19.5 84 H 22');+ expect(frames).toHaveLength(0);++ /** From the third row to the second, sampled every 10ms. */+ pointer('pointermove', rows.b2, 150, 'mouse', false);+ frameAt(2000);+ const seen: Array<ReturnType<typeof shape>> = [];+ for (let now = 2000; frames.length > 0; now += 10) {+ frameAt(now);+ seen.push(shape());+ }+ expect(seen[seen.length - 1].d).toBe('M 11.5 2 V 44 A 8 8 0 0 0 19.5 52 H 22');+ for (let i = 0; i < seen.length; i++) {+ const { tip, branch } = seen[i];+ /** Never above the row it is heading for, never back via the top. */+ expect(tip).toBeGreaterThanOrEqual(44);+ expect(tip).toBeLessThanOrEqual(76);+ if (i > 0) {+ expect(tip).toBeLessThanOrEqual(seen[i - 1].tip);+ }+ /** A branch is only ever drawn from a branch point, so nothing leaves the tree. */+ if (branch) {+ expect([44, 76]).toContain(tip);+ }+ }+ expect(seen.some(({ tip, branch }) => !branch && tip > 44 && tip < 76)).toBe(true);+ });++ it('keeps traveling, without a jump, when the row it is heading for moves mid-trip', async () => {+ const { root, b, rows } = foldFixture();+ const path = traced(b.rail, [20, 52, 84]);+ renderHook(() => useFoldPath({ current: root }, true));+ const tipOf = () => Number(/V ([\d.]+)/.exec(path.getAttribute('d') ?? '')?.[1]);+ const frameAt = (now: number) => {+ const pending = frames;+ frames = [];+ pending.forEach((callback) => callback(now));+ };++ pointer('pointermove', rows.b1, 120, 'mouse', false);+ frameAt(0);+ frameAt(0);+ frameAt(1000);+ expect(tipOf()).toBe(12);++ pointer('pointermove', rows.b3, 180, 'mouse', false);+ frameAt(2000);+ const tips = [tipOf()];+ for (let now = 2000; now <= 2040; now += 5) {+ frameAt(now);+ tips.push(tipOf());+ }+ /** A fold above the third row opens: the row is 16px further down now. */+ hit.mockReturnValue(rows.b3);+ b.rail.dataset.centers = '20,52,100';+ await Promise.resolve();+ for (let now = 2045; frames.length > 0; now += 5) {+ frameAt(now);+ tips.push(tipOf());+ }+ expect(path).toHaveAttribute('d', 'M 11.5 2 V 92 A 8 8 0 0 0 19.5 100 H 22');+ for (let i = 1; i < tips.length; i++) {+ expect(tips[i]).toBeGreaterThanOrEqual(tips[i - 1]);+ expect(tips[i] - tips[i - 1]).toBeLessThan(10);+ }+ });++ it('follows no touch, and clears on a touch press', () => {const { root, a, rows } = foldFixture();renderHook(() => useFoldPath({ current: root }, true));@@ -343,17 +448,34 @@ describe('useFoldPath', () => {expect(a.rail.dataset.foldLit).toBeUndefined();pointer('pointermove', rows.a1, 55);- expect(a.rail.dataset.foldLit).toBe('end');- pointer('pointerdown', rows.a1, 55);+ expect(a.rail.dataset.foldLit).toBe('0');+ pointer('pointerdown', rows.a1, 55, 'touch');expect(a.rail.dataset.foldLit).toBeUndefined();});- it('cancels a queued paint when the pointer presses before the frame', () => {+ it('keeps the path through a click that folds the rows, re-hit under the pointer', async () => {+ const { root, a, b, rows } = foldFixture();+ renderHook(() => useFoldPath({ current: root }, true));+ pointer('pointermove', rows.b2, 150);+ expect(b.rail.dataset.foldLit).toBe('1');++ /** Folding the group unmounts its panel; the group's header is now under the pointer. */+ hit.mockReturnValue(rows.header);+ pointer('pointerdown', rows.b2, 150);+ b.el.remove();+ await Promise.resolve();+ flushFrames();+ expect(hit).toHaveBeenCalledWith(100, 150);+ expect(b.rail.dataset.foldLit).toBeUndefined();+ expect(a.rail.dataset.foldLit).toBe('1');+ });++ it('cancels a queued paint when a touch presses before the frame', () => {const { root, a, b, rows } = foldFixture();renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b2, 150, 'mouse', false);expect(frames).toHaveLength(1);- pointer('pointerdown', rows.b2, 150);+ pointer('pointerdown', rows.b2, 150, 'touch');expect(window.cancelAnimationFrame).toHaveBeenCalledWith(1);expect(frames).toHaveLength(0);expect(a.rail.dataset.foldLit).toBeUndefined();@@ -366,74 +488,98 @@ describe('useFoldPath', () => {renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b1, 120);await Promise.resolve();- expect(b.rail.dataset.foldLit).toBe('end');+ expect(b.rail.dataset.foldLit).toBe('0');pointer('pointermove', rows.b2, 150);pointer('pointermove', rows.b3, 180);expect(query).toHaveBeenCalledTimes(1);- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('82px');+ expect(b.rail.dataset.foldLit).toBe('2');});- it('clears on streamed text changes without relighting a queued frame', async () => {+ it('relights under the pointer when streamed text moves the rows', async () => {const { root, b, rows } = foldFixture();rows.b1.append(document.createTextNode('output'));renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b2, 150);- await Promise.resolve();- pointer('pointermove', rows.b2, 150, 'mouse', false);+ expect(b.rail.dataset.foldLit).toBe('1');++ /** The first row's output grows and pushes the rows below it out from under the pointer. */+ rows.b2.getBoundingClientRect = () => ({ top: 178, height: 20 }) as DOMRect;+ rows.b3.getBoundingClientRect = () => ({ top: 210, height: 20 }) as DOMRect;+ hit.mockReturnValue(rows.b1);rows.b1.firstChild!.textContent = 'growing output';await Promise.resolve();flushFrames();- expect(b.rail.dataset.foldLit).toBeUndefined();- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('');+ expect(b.rail.dataset.foldLit).toBe('0');+ });++ it('uses a fresh move over a pending re-hit in the same frame', async () => {+ const { root, b, rows } = foldFixture();+ renderHook(() => useFoldPath({ current: root }, true));+ pointer('pointermove', rows.b1, 120);+ rows.b1.setAttribute('class', 'fold-glyph changed');+ await Promise.resolve();+ pointer('pointermove', rows.b3, 180);+ expect(hit).not.toHaveBeenCalled();+ expect(b.rail.dataset.foldLit).toBe('2');});it('rebuilds cached glyphs after rows are inserted or removed', async () => {const { root, b, rows } = foldFixture();const query = jest.spyOn(b.el, 'querySelectorAll');renderHook(() => useFoldPath({ current: root }, true));+ hit.mockReturnValue(rows.b1);pointer('pointermove', rows.b1, 120);const added = rows.b2.cloneNode() as HTMLElement;added.getBoundingClientRect = () => ({ top: 210, height: 20 }) as DOMRect;b.el.append(added);await Promise.resolve();- expect(b.rail.dataset.foldLit).toBeUndefined();+ flushFrames();+ expect(b.rail.dataset.foldLit).toBe('0');pointer('pointermove', added, 215);- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('114px');+ expect(b.rail.dataset.foldLit).toBe('3');added.remove();await Promise.resolve();pointer('pointermove', rows.b3, 180);- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('82px');+ expect(b.rail.dataset.foldLit).toBe('2');expect(query).toHaveBeenCalledTimes(3);});- it.each(['class', 'style', 'hidden', 'open'])(- 'clears on a disclosure %s change',+ it.each(['class', 'style', 'hidden', 'open', 'data-centers'])(+ 're-hits on a disclosure %s change',async (attribute) => {const { root, b, rows } = foldFixture();renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b2, 150);rows.b1.setAttribute(attribute, 'changed');await Promise.resolve();+ flushFrames();+ expect(hit).toHaveBeenCalledWith(100, 150);expect(b.rail.dataset.foldLit).toBeUndefined();},);- it('clears when resizing or scrolling moves the hovered row', () => {+ it('re-hits when resizing or scrolling moves the rows under the pointer', () => {const { root, b, rows } = foldFixture();renderHook(() => useFoldPath({ current: root }, true));+ hit.mockReturnValue(rows.b2);pointer('pointermove', rows.b2, 150);resize([], {} as ResizeObserver);- expect(b.rail.dataset.foldLit).toBeUndefined();- pointer('pointermove', rows.b2, 150);+ flushFrames();+ expect(b.rail.dataset.foldLit).toBe('1');root.dispatchEvent(new Event('scroll'));- expect(b.rail.dataset.foldLit).toBeUndefined();- pointer('pointermove', rows.b2, 150);+ flushFrames();+ expect(b.rail.dataset.foldLit).toBe('1');+ expect(hit).toHaveBeenCalledTimes(2);++ /** Scrolled out from under the pointer: nothing of this fold is there any more. */+ hit.mockReturnValue(document.body);window.dispatchEvent(new Event('resize'));+ flushFrames();expect(b.rail.dataset.foldLit).toBeUndefined();});it.each([false, true])(- 'clears after a preceding message shifts the fold, with a queued paint=%s',+ 'relights after a preceding message shifts the fold, with a queued paint=%s',(queued) => {const { root, a, b, rows } = foldFixture();const transcript = document.createElement('div');@@ -453,24 +599,18 @@ describe('useFoldPath', () => {const query = jest.spyOn(b.el, 'querySelectorAll');const { unmount } = renderHook(() => useFoldPath({ current: root }, true));pointer('pointermove', rows.b2, 150);- expect(b.rail.dataset.foldLit).toBe('end');+ expect(b.rail.dataset.foldLit).toBe('1');if (queued) {pointer('pointermove', rows.b2, 150, 'mouse', false);}+ /** 32px down, the row above the one that was hovered is now under the pointer. */offset = 32;- if (observe.mock.calls.some(([element]) => element === transcript)) {- resize([], {} as ResizeObserver);- }+ hit.mockReturnValue(rows.b1);+ expect(observe.mock.calls.some(([element]) => element === transcript)).toBe(true);+ resize([], {} as ResizeObserver);flushFrames();- expect(root.getBoundingClientRect()).toMatchObject({ top: 32, height: 250 });- expect(message.getBoundingClientRect()).toMatchObject({ top: 32, height: 250 });- expect(a.rail.dataset.foldLit).toBeUndefined();- expect(b.rail.dataset.foldLit).toBeUndefined();- expect(a.rail.style.getPropertyValue('--fold-lit')).toBe('');- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('');- pointer('pointermove', rows.b1, 150);- expect(b.rail.dataset.foldLit).toBe('end');- expect(b.rail.style.getPropertyValue('--fold-lit')).toBe('18px');+ expect(b.rail.dataset.foldLit).toBe('0');+ expect(a.rail.dataset.foldLit).toBe('1');expect(query).toHaveBeenCalledTimes(1);unmount();expect(disconnect).toHaveBeenCalledTimes(1);@@ -480,45 +620,32 @@ describe('useFoldPath', () => {it('re-hit-tests one queued paint after scrolling instead of discarding a fresh move', () => {const { root, a, b, rows } = foldFixture();rows.a2.getBoundingClientRect = () => ({ top: 140, height: 20 }) as DOMRect;- const hit = jest.fn(() => rows.a2);- Object.defineProperty(document, 'elementFromPoint', { configurable: true, value: hit });- try {- renderHook(() => useFoldPath({ current: root }, true));- pointer('pointermove', rows.b2, 150, 'mouse', false);- root.dispatchEvent(new Event('scroll'));- root.dispatchEvent(new Event('scroll'));- expect(frames).toHaveLength(1);- expect(hit).not.toHaveBeenCalled();- flushFrames();- expect(hit).toHaveBeenCalledTimes(1);- expect(hit).toHaveBeenCalledWith(100, 150);- expect(b.rail.dataset.foldLit).toBeUndefined();- expect(a.rail.dataset.foldLit).toBe('end');- expect(a.rail.style.getPropertyValue('--fold-lit')).toBe('108px');- } finally {- Reflect.deleteProperty(document, 'elementFromPoint');- }+ hit.mockReturnValue(rows.a2);+ renderHook(() => useFoldPath({ current: root }, true));+ pointer('pointermove', rows.b2, 150, 'mouse', false);+ root.dispatchEvent(new Event('scroll'));+ root.dispatchEvent(new Event('scroll'));+ expect(frames).toHaveLength(1);+ expect(hit).not.toHaveBeenCalled();+ flushFrames();+ expect(hit).toHaveBeenCalledTimes(1);+ expect(hit).toHaveBeenCalledWith(100, 150);+ expect(b.rail.dataset.foldLit).toBeUndefined();+ expect(a.rail.dataset.foldLit).toBe('2');});it.each([null, document.body])('clears a queued path when scrolling moves the pointer outside the fold (%p)',(target) => {const { root, a, b, rows } = foldFixture();- Object.defineProperty(document, 'elementFromPoint', {- configurable: true,- value: jest.fn(() => target),- });- try {- renderHook(() => useFoldPath({ current: root }, true));- pointer('pointermove', rows.b2, 150);- pointer('pointermove', rows.b3, 180, 'mouse', false);- root.dispatchEvent(new Event('scroll'));- flushFrames();- expect(a.rail.dataset.foldLit).toBeUndefined();- expect(b.rail.dataset.foldLit).toBeUndefined();- } finally {- Reflect.deleteProperty(document, 'elementFromPoint');- }+ hit.mockReturnValue(target);+ renderHook(() => useFoldPath({ current: root }, true));+ pointer('pointermove', rows.b2, 150);+ pointer('pointermove', rows.b3, 180, 'mouse', false);+ root.dispatchEvent(new Event('scroll'));+ flushFrames();+ expect(a.rail.dataset.foldLit).toBeUndefined();+ expect(b.rail.dataset.foldLit).toBeUndefined();},);@@ -558,20 +685,77 @@ describe('useFoldPath', () => {rerender({ hasBody: true });pointer('pointermove', rows.b2, 150);- expect(b.rail.dataset.foldLit).toBe('end');+ expect(b.rail.dataset.foldLit).toBe('1');});});-describe('FoldRail path segment', () => {- it('draws the lit path inside the rail, hidden from assistive tech', () => {- function Rail() {- const hover = useRailHover();- return <FoldRail hover={hover} expanded onCollapse={jest.fn()} />;- }- render(<Rail />);+describe('FoldRail branches', () => {+ let measure: ResizeObserverCallback;++ beforeEach(() => {+ /** The rail measures in a layout effect, before its later siblings' refs attach. */+ jest.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (+ this: HTMLElement,+ ) {+ return { top: Number(this.dataset.top ?? 0), height: 20 } as DOMRect;+ });+ jest.spyOn(window, 'ResizeObserver').mockImplementation((callback) => {+ measure = callback;+ return { observe: jest.fn(), unobserve: jest.fn(), disconnect: jest.fn() };+ });+ });++ afterEach(() => {+ jest.restoreAllMocks();+ });++ function Panel({ rows, expanded = true }: { rows: number[]; expanded?: boolean }) {+ const hover = useRailHover();+ return (+ <div data-fold-panel="">+ <FoldRail hover={hover} expanded={expanded} onCollapse={jest.fn()} />+ {rows.map((top) => (+ <span key={top} className="fold-glyph" data-top={top} />+ ))}+ <div data-fold-panel="">+ <span className="fold-glyph" data-top={500} />+ </div>+ </div>+ );+ }++ it('branches the trunk into each of its own rows, hidden from assistive tech', () => {+ render(<Panel rows={[6, 38]} />);const rail = screen.getByTestId('fold-rail');- expect(rail).toHaveAttribute('data-fold-rail');expect(rail).toHaveAttribute('aria-hidden', 'true');- expect(rail).toContainElement(screen.getByTestId('fold-rail-path'));+ expect(rail).toHaveAttribute('data-centers', '16,48');+ const drawn = Array.from(screen.getByTestId('fold-rail-tree').querySelectorAll('g > path'));+ expect(drawn.map((path) => path.getAttribute('d'))).toEqual([+ 'M 11.5 2 V 40',+ 'M 11.5 8 A 8 8 0 0 0 19.5 16 H 22',+ 'M 11.5 40 A 8 8 0 0 0 19.5 48 H 22',+ ]);+ /** The lit path has no shape until `useFoldPath` traces it to a row. */+ expect(screen.getByTestId('fold-rail-path')).not.toHaveAttribute('d');+ });++ it('adds a branch when a streamed row resizes the panel', () => {+ const { rerender } = render(<Panel rows={[6]} />);+ expect(screen.getByTestId('fold-rail')).toHaveAttribute('data-centers', '16');+ rerender(<Panel rows={[6, 38]} />);+ act(() => measure([], {} as ResizeObserver));+ expect(screen.getByTestId('fold-rail')).toHaveAttribute('data-centers', '16,48');+ });++ it('keeps a plain hairline for a panel without rows of its own', () => {+ render(<Panel rows={[]} />);+ expect(screen.queryByTestId('fold-rail-tree')).toBeNull();+ });++ it('fades the branches out as the fold collapses', () => {+ const { rerender } = render(<Panel rows={[6]} />);+ expect(screen.getByTestId('fold-rail-tree')).toHaveClass('opacity-100');+ rerender(<Panel rows={[6]} expanded={false} />);+ expect(screen.getByTestId('fold-rail-tree')).toHaveClass('opacity-0');});});diff --git a/client/src/components/Chat/Messages/Content/rail.tsx b/client/src/components/Chat/Messages/Content/rail.tsxindex 62cfb48a0a..35eae36628 100644--- a/client/src/components/Chat/Messages/Content/rail.tsx+++ b/client/src/components/Chat/Messages/Content/rail.tsx@@ -1,4 +1,11 @@-import { createContext, useEffect, useState, useSyncExternalStore } from 'react';+import {+ useRef,+ useState,+ useEffect,+ createContext,+ useLayoutEffect,+ useSyncExternalStore,+} from 'react';import { CircleMinus } from 'lucide-react';import type { ReactNode, RefObject } from 'react';import { ROW_GLYPH_SLOT, FOLD_GLYPH_SELECTOR } from './rows';@@ -65,12 +72,103 @@ export function RailGlyph({ hover, children }: { hover: RailHover; children: Rea);}+const FOLD_PANEL = '[data-fold-panel]';+const FOLD_RAIL = '[data-fold-rail]';+const FOLD_ROOT = '[data-fold-root]';+const FOLD_COLUMN = '[data-fold-column]';+/** A row's glyph is 20px tall inside a 32px line, so the pointer is on that row from+ * the margin above the glyph down to the next row's margin. */+const ROW_REACH = 6;++/** The row glyphs of one panel or column, in document order, which within that scope+ * is vertical order. Rows of nested folds belong to those folds. */+function glyphsIn(panel: Element, scope: Element): Element[] {+ const glyphs: Element[] = [];+ for (const glyph of scope.querySelectorAll(FOLD_GLYPH_SELECTOR)) {+ if (glyph.closest(FOLD_PANEL) === panel && scopeOf(panel, glyph) === scope) {+ glyphs.push(glyph);+ }+ }+ return glyphs;+}++/** The column of `panel` that holds `node`, or the panel itself. */+function scopeOf(panel: Element, node: Element): Element {+ const column = node.closest(FOLD_COLUMN);+ return column != null && panel.contains(column) ? column : panel;+}++/** Branch geometry in the rail's 24px inset: the trunk under the header glyph's+ * center, an elbow of `BRANCH_RADIUS` and a stub that stops short of the row's glyph. */+const TRUNK_X = 11.5;+const TRUNK_TOP = 2;+const BRANCH_RADIUS = 8;+const BRANCH_END = 22;++/** Where a row's branch leaves the trunk: one radius above the row's center. */+function branchStart(center: number) {+ return center - Math.max(Math.min(BRANCH_RADIUS, center - TRUNK_TOP), 0);+}++/** The curve from the trunk into the row, continuing a path already at `branchStart`. */+function elbow(center: number) {+ const r = center - branchStart(center);+ return `A ${r} ${r} 0 0 0 ${TRUNK_X + r} ${center} H ${BRANCH_END}`;+}++function sameCenters(a: number[], b: number[]) {+ return a.length === b.length && a.every((value, i) => value === b[i]);+}++/** Vertical centers of the panel's own row glyphs, relative to the rail's top. */+function useBranchCenters(railRef: RefObject<HTMLButtonElement>) {+ const [centers, setCenters] = useState<number[]>([]);+ useLayoutEffect(() => {+ const rail = railRef.current;+ const panel = rail?.parentElement;+ if (rail == null || panel == null || !panel.matches(FOLD_PANEL)) {+ return;+ }+ const measure = () => {+ const top = rail.getBoundingClientRect().top;+ const next = glyphsIn(panel, panel).map((glyph) => {+ const rect = glyph.getBoundingClientRect();+ return Math.round(rect.top + rect.height / 2 - top);+ });+ setCenters((previous) => (sameCenters(previous, next) ? previous : next));+ };+ measure();+ /** Rows arriving or a nested fold opening resize the panel or the wrapper that holds+ * the rows; that is when branches move. A panel's own height can be pinned while it+ * animates, so its children are watched too, including ones mounted later. */+ const resize = new ResizeObserver(measure);+ const observeChildren = () => {+ for (const child of panel.children) {+ resize.observe(child);+ }+ };+ resize.observe(panel);+ observeChildren();+ const children = new MutationObserver(() => {+ observeChildren();+ measure();+ });+ children.observe(panel, { childList: true });+ return () => {+ resize.disconnect();+ children.disconnect();+ };+ }, [railRef]);+ return centers;+}+/**- * The hairline that hangs from an open header's glyph, drawn inside a hit area- * the width of the panel's inset so the pointer only has to come near it. A- * pointer shortcut only: the header button stays the one control keyboard and- * screen-reader users reach, so the rail is hidden from both and never takes- * focus. Must sit in a `FOLD_RAIL_CLASSES` wrapper, whose inset it fills.+ * The trunk that hangs from an open header's glyph and branches into each of its+ * rows, drawn inside a hit area the width of the panel's inset so the pointer only+ * has to come near it. A panel without rows of its own (parallel columns) keeps a+ * plain hairline. A pointer shortcut only: the header button stays the one control+ * keyboard and screen-reader users reach, so the rail is hidden from both and never+ * takes focus. Must sit in a `FOLD_RAIL_CLASSES` wrapper, whose inset it fills.*/export function FoldRail({hover,@@ -81,6 +179,8 @@ export function FoldRail({expanded: boolean;onCollapse: () => void;}) {+ const railRef = useRef<HTMLButtonElement>(null);+ const centers = useBranchCenters(railRef);/** Collapsed approval bodies stay mounted without a pointer leave. */useEffect(() => {if (!expanded) {@@ -88,8 +188,10 @@ export function FoldRail({}return () => hover.set(false);}, [hover, expanded]);+ const last = centers[centers.length - 1];return (<button+ ref={railRef}type="button"tabIndex={-1}aria-hidden="true"@@ -104,68 +206,77 @@ export function FoldRail({}}data-testid="fold-rail"data-fold-rail=""+ data-centers={centers.join(',')}>- <span className="bg-border-medium group-hover/rail:bg-text-secondary absolute inset-s-[11px] top-0.5 bottom-1.5 w-px transition-colors duration-150 motion-reduce:transition-none" />- {/* The lit path (`useFoldPath`): from the header down to the hovered row, turning- into that row when it is this fold's own. */}- <span- className="border-text-secondary pointer-events-none absolute inset-s-[11px] top-0.5 h-(--fold-lit) border-s opacity-0 transition-opacity duration-150 group-data-fold-lit/rail:opacity-100 group-data-[fold-lit=end]/rail:w-2 group-data-[fold-lit=end]/rail:rounded-es-md group-data-[fold-lit=end]/rail:border-b motion-reduce:transition-none"- data-testid="fold-rail-path"- />+ {last == null ? (+ <span className="bg-border-medium group-hover/rail:bg-text-secondary absolute inset-s-[11px] top-0.5 bottom-1.5 w-px transition-colors duration-150 motion-reduce:transition-none" />+ ) : (+ <svg+ className={cn(+ 'pointer-events-none absolute inset-0 size-full overflow-visible rtl:-scale-x-100',+ 'transition-opacity motion-reduce:transition-none',+ expanded ? 'opacity-100 delay-100 duration-250' : 'opacity-0 duration-200',+ )}+ fill="none"+ strokeLinecap="round"+ strokeLinejoin="round"+ data-testid="fold-rail-tree"+ >+ <g className="stroke-border-medium group-hover/rail:stroke-text-secondary transition-colors duration-150 motion-reduce:transition-none">+ <path d={`M ${TRUNK_X} ${TRUNK_TOP} V ${branchStart(last)}`} />+ {centers.map((center, i) => (+ <path key={i} d={`M ${TRUNK_X} ${branchStart(center)} ${elbow(center)}`} />+ ))}+ </g>+ {/* The lit path (`useFoldPath`): one trunk-and-elbow whose foot slides to the+ hovered row (`traceTo`), so it always travels the route between rows. */}+ <path+ className="stroke-text-secondary opacity-0 transition-opacity duration-150 data-lit:opacity-100 motion-reduce:transition-none"+ data-fold-trace=""+ data-testid="fold-rail-path"+ />+ </svg>+ )}</button>);}-const FOLD_PANEL = '[data-fold-panel]';-const FOLD_RAIL = '[data-fold-rail]';-const FOLD_ROOT = '[data-fold-root]';-const FOLD_COLUMN = '[data-fold-column]';-/** A row's glyph is 20px tall inside a 32px line, so the pointer is on that row from- * the margin above the glyph down to the next row's margin. */-const ROW_REACH = 6;--export type LitRail = { rail: HTMLElement; length: number; end: boolean };+/** A fold to light: the rail and the index of its own row the path ends in. */+export type LitRail = { rail: HTMLElement; branch: number };-/** The glyph at `y` in one panel or column, or the nearest above an open body.- * Within that scope, document order is vertical order. */+/** The glyph at `y` in one panel or column, or the nearest above an open body. */function glyphAt(panel: Element,scope: Element,y: number,glyphsByPanel: WeakMap<Element, Element[]>,-): Element | null {+): { glyph: Element; index: number } | null {let glyphs = glyphsByPanel.get(scope);if (glyphs == null) {- glyphs = [];- for (const glyph of scope.querySelectorAll(FOLD_GLYPH_SELECTOR)) {- const column = glyph.closest(FOLD_COLUMN);- const glyphScope = column != null && panel.contains(column) ? column : panel;- if (glyph.closest(FOLD_PANEL) === panel && glyphScope === scope) {- glyphs.push(glyph);- }- }+ glyphs = glyphsIn(panel, scope);glyphsByPanel.set(scope, glyphs);}- let found: Element | null = null;+ let found = -1;let low = 0;let high = glyphs.length - 1;while (low <= high) {const mid = (low + high) >> 1;if (glyphs[mid].getBoundingClientRect().top - ROW_REACH <= y) {- found = glyphs[mid];+ found = mid;low = mid + 1;} else {high = mid - 1;}}- return found;+ return found < 0 ? null : { glyph: glyphs[found], index: found };}/*** The rails to light for a pointer at `y` over `target`: one per fold that holds the- * row under it, innermost first, each `length` px from its top to that row's center.- * Empty over a rail itself, whose own hover shows what it collapses, and over any- * header that no fold of `root` holds.+ * row under it, innermost first, each ending in the branch of its own row that leads+ * there (for an outer fold, the header of the nested one). Rows inside a parallel+ * column have no branch, so their fold stays dark. Empty over a rail itself, whose own+ * hover shows what it collapses, and over any header that no fold of `root` holds.*/export function litFoldPath(root: Element,@@ -180,44 +291,224 @@ export function litFoldPath(if (innermost == null || !root.contains(innermost)) {return [];}- const column = target.closest(FOLD_COLUMN);- const scope = column != null && innermost.contains(column) ? column : innermost;- const glyph = glyphAt(innermost, scope, y, glyphsByPanel);- if (glyph == null) {- return [];- }- const { top, height } = glyph.getBoundingClientRect();- const center = top + height / 2;const path: LitRail[] = [];+ let node: Element = target;let panel: Element | null = innermost;while (panel != null && root.contains(panel)) {+ const scope = scopeOf(panel, node);const rail = panel.querySelector<HTMLElement>(`:scope > ${FOLD_RAIL}`);- if (rail != null) {- /** The path starts where the rail's own line does, 2px below the panel. */- const length = Math.round(center - rail.getBoundingClientRect().top) - 2;- path.push({ rail, length: Math.max(length, 0), end: path.length === 0 });+ const hit = glyphAt(panel, scope, y, glyphsByPanel);+ if (rail != null && hit != null && scope === panel) {+ path.push({ rail, branch: hit.index });}+ node = panel;panel = panel.parentElement?.closest(FOLD_PANEL) ?? null;}return path;}+/**+ * A rail's lit path while it is shown. It only ever lies on the drawn tree: the trunk+ * from the top down to `tip`, then, once the tip rests on a branch point, `elbow` px+ * of that row's branch (centered at `center`).+ */+type Trace = {+ path: SVGPathElement;+ branch: number;+ center: number;+ tip: number;+ elbow: number;+ move: TraceMove | null;+ frame: number;+ fade: number;+};++/** One trip along the tree: back out of the current branch, along the trunk, into the next. */+type TraceMove = {+ from: { center: number; tip: number; elbow: number };+ branch: number;+ center: number;+ retract: number;+ travel: number;+ /** How much of the new row's branch is already drawn when the trip starts. */+ extendFrom: number;+ total: number;+ duration: number;+ start: number | null;+};++const traces = new WeakMap<HTMLElement, Trace>();+/** The pace along the tree, bounded so a hop to the next row and a long run both read. */+const TRACE_MS_PER_PX = 2.2;+const TRACE_MIN_MS = 140;+const TRACE_MAX_MS = 320;+/** Long enough for the path's fade-out, after which it next enters from the top. */+const TRACE_FADE_MS = 160;+const FOLD_TRACE = '[data-fold-trace]';++const easeOut = (t: number) => 1 - (1 - t) ** 3;++function prefersReducedMotion() {+ return window.matchMedia?.('(prefers-reduced-motion: reduce)').matches === true;+}++/** Length of a row's branch: the quarter turn off the trunk, then the stub to the row. */+function branchLength(center: number) {+ const r = center - branchStart(center);+ return (Math.PI * r) / 2 + (BRANCH_END - TRUNK_X - r);+}++/** The first `length` px of a row's branch, continuing a path that is at its start. */+function partialBranch(center: number, length: number) {+ const r = center - branchStart(center);+ const arc = (Math.PI * r) / 2;+ if (length >= arc) {+ const end = Math.min(BRANCH_END, Math.round((TRUNK_X + r + length - arc) * 100) / 100);+ return `A ${r} ${r} 0 0 0 ${TRUNK_X + r} ${center} H ${end}`;+ }+ const angle = r === 0 ? 0 : length / r;+ const x = TRUNK_X + r - r * Math.cos(angle);+ const y = center - r + r * Math.sin(angle);+ return `A ${r} ${r} 0 0 0 ${x} ${y}`;+}++function drawTrace(trace: Trace) {+ const branch = trace.elbow > 0 ? ` ${partialBranch(trace.center, trace.elbow)}` : '';+ trace.path.setAttribute('d', `M ${TRUNK_X} ${TRUNK_TOP} V ${trace.tip}${branch}`);+}++/** Where a move has the path after `distance` px of it. */+function stepMove(trace: Trace, move: TraceMove, distance: number) {+ const { from } = move;+ if (distance < move.retract) {+ trace.center = from.center;+ trace.tip = from.tip;+ trace.elbow = from.elbow - distance;+ return;+ }+ const along = distance - move.retract;+ const target = branchStart(move.center);+ if (along < move.travel) {+ trace.elbow = 0;+ trace.tip = from.tip + Math.sign(target - from.tip) * along;+ return;+ }+ trace.center = move.center;+ trace.tip = target;+ trace.elbow = Math.min(move.extendFrom + along - move.travel, branchLength(move.center));+}++/**+ * Lights a rail's path into the row `to` names, or fades it out for `null`. The path+ * travels the tree's own route: it backs out of the branch it is in, runs along the+ * trunk to the new row's branch point and draws into that branch, as one motion at a+ * steady pace. Retargeting mid-trip starts the new trip from wherever it is. When the+ * same row moves (a fold above it opened), the path follows it at once.+ */+function traceTo(rail: HTMLElement, to: { branch: number; center: number } | null) {+ const path = rail.querySelector<SVGPathElement>(FOLD_TRACE);+ let trace = traces.get(rail);+ if (to == null || path == null) {+ if (trace != null) {+ cancelAnimationFrame(trace.frame);+ trace.frame = 0;+ trace.move = null;+ /** A path left mid-trip finishes its trip if the pointer comes straight back. */+ trace.branch = -1;+ trace.path.removeAttribute('data-lit');+ window.clearTimeout(trace.fade);+ trace.fade = window.setTimeout(() => traces.delete(rail), TRACE_FADE_MS);+ }+ return;+ }+ if (trace == null || trace.path !== path) {+ /** Enters from the top, never from where a faded-out path last ended. */+ trace = {+ path,+ branch: -1,+ center: TRUNK_TOP,+ tip: TRUNK_TOP,+ elbow: 0,+ move: null,+ frame: 0,+ fade: 0,+ };+ traces.set(rail, trace);+ drawTrace(trace);+ }+ window.clearTimeout(trace.fade);+ path.setAttribute('data-lit', '');++ const settled = trace.move == null && trace.branch === to.branch;+ if (settled && trace.center === to.center) {+ return;+ }+ if (settled || prefersReducedMotion()) {+ cancelAnimationFrame(trace.frame);+ trace.frame = 0;+ trace.move = null;+ trace.branch = to.branch;+ trace.center = to.center;+ trace.tip = branchStart(to.center);+ trace.elbow = branchLength(to.center);+ drawTrace(trace);+ return;+ }+ /** A row that moved mid-trip gets a fresh trip from where the path is now, so the+ * remaining distance is measured to where the row actually is. */+ if (trace.move != null && trace.move.branch === to.branch && trace.move.center === to.center) {+ return;+ }++ cancelAnimationFrame(trace.frame);+ const target = branchStart(to.center);+ /** Turning back into the branch it is still partly in: keep what is drawn. */+ const resume = trace.elbow > 0 && trace.center === to.center && trace.tip === target;+ const retract = resume ? 0 : trace.elbow;+ const extendFrom = resume ? trace.elbow : 0;+ const travel = Math.abs(target - trace.tip);+ const total = retract + travel + branchLength(to.center) - extendFrom;+ const move: TraceMove = {+ from: { center: trace.center, tip: trace.tip, elbow: trace.elbow },+ branch: to.branch,+ center: to.center,+ retract,+ travel,+ extendFrom,+ total,+ duration: Math.min(TRACE_MAX_MS, Math.max(TRACE_MIN_MS, total * TRACE_MS_PER_PX)),+ start: null,+ };+ trace.move = move;+ trace.branch = to.branch;+ const current = trace;+ const step = (now: number) => {+ move.start ??= now;+ const t = Math.min(1, (now - move.start) / move.duration);+ stepMove(current, move, move.total * easeOut(t));+ drawTrace(current);+ if (t < 1) {+ current.frame = requestAnimationFrame(step);+ return;+ }+ current.frame = 0;+ current.move = null;+ };+ current.frame = requestAnimationFrame(step);+}+function paintFoldPath(previous: LitRail[], next: LitRail[]) {for (const { rail } of previous) {if (!next.some((lit) => lit.rail === rail)) {delete rail.dataset.foldLit;- rail.style.removeProperty('--fold-lit');+ traceTo(rail, null);}}- for (const { rail, length, end } of next) {- const kind = end ? 'end' : 'through';- if (rail.dataset.foldLit !== kind) {- rail.dataset.foldLit = kind;- }- const value = `${length}px`;- if (rail.style.getPropertyValue('--fold-lit') !== value) {- rail.style.setProperty('--fold-lit', value);- }+ for (const { rail, branch } of next) {+ rail.dataset.foldLit = String(branch);+ /** Re-read on every paint: a re-hit after a layout change can move the branch. */+ const center = Number(rail.dataset.centers?.split(',')[branch]);+ traceTo(rail, rail.dataset.centers && Number.isFinite(center) ? { branch, center } : null);}}@@ -268,17 +559,30 @@ export function useFoldPath(rootRef: RefObject<HTMLElement>, hasBody: boolean) {return;}pointer = { target: event.target, x: event.clientX, y: event.clientY };+ /** The move's own target is current; a layout change after it sets this again. */+ rehit = false;if (frame === 0) {frame = requestAnimationFrame(paint);}};- const onScroll = () => {- /** Scroll events can arrive after a fresh move but before its queued paint. */- if (frame !== 0) {- rehit = true;+ /** The rows moved under a pointer that did not: hit-test its last position again+ * on the next frame rather than going dark until the pointer next moves. Clicking+ * a header to fold or unfold it, streaming, scrolling and resizing all land here. */+ const relight = () => {+ if (pointer == null) {return;}- clear();+ rehit = true;+ if (frame === 0) {+ frame = requestAnimationFrame(paint);+ }+ };+ const onDown = (event: PointerEvent) => {+ if (event.pointerType === 'touch') {+ clear();+ return;+ }+ relight();};const mutations = new MutationObserver((records) => {let changed = false;@@ -300,7 +604,7 @@ export function useFoldPath(rootRef: RefObject<HTMLElement>, hasBody: boolean) {glyphsByPanel = new WeakMap();}if (changed) {- clear();+ relight();}});mutations.observe(root, {@@ -308,9 +612,17 @@ export function useFoldPath(rootRef: RefObject<HTMLElement>, hasBody: boolean) {childList: true,characterData: true,attributes: true,- attributeFilter: ['class', 'style', 'hidden', 'open', 'data-fold-panel', 'data-fold-column'],+ attributeFilter: [+ 'class',+ 'style',+ 'hidden',+ 'open',+ 'data-centers',+ 'data-fold-panel',+ 'data-fold-column',+ ],});- const resize = new ResizeObserver(clear);+ const resize = new ResizeObserver(relight);/** Earlier messages can move this fold without resizing it. */for (let ancestor: HTMLElement | null = root;@@ -321,15 +633,15 @@ export function useFoldPath(rootRef: RefObject<HTMLElement>, hasBody: boolean) {}root.addEventListener('pointermove', onMove);root.addEventListener('pointerleave', clear);- root.addEventListener('pointerdown', clear);- window.addEventListener('scroll', onScroll, true);- window.addEventListener('resize', clear);+ root.addEventListener('pointerdown', onDown);+ window.addEventListener('scroll', relight, true);+ window.addEventListener('resize', relight);return () => {root.removeEventListener('pointermove', onMove);root.removeEventListener('pointerleave', clear);- root.removeEventListener('pointerdown', clear);- window.removeEventListener('scroll', onScroll, true);- window.removeEventListener('resize', clear);+ root.removeEventListener('pointerdown', onDown);+ window.removeEventListener('scroll', relight, true);+ window.removeEventListener('resize', relight);mutations.disconnect();resize.disconnect();clear();diff --git a/e2e/specs/mock/activity-fold.spec.ts b/e2e/specs/mock/activity-fold.spec.tsindex 8101ffc74d..1e4e71bca1 100644--- a/e2e/specs/mock/activity-fold.spec.ts+++ b/e2e/specs/mock/activity-fold.spec.ts@@ -152,30 +152,39 @@ test.describe('activity fold', () => {const groupHeader = groupPanel.locator('xpath=preceding-sibling::div[1]').getByRole('button');const lineColor = (railLocator: typeof groupRail) =>railLocator- .locator('span')+ .locator('g > path').first()- .evaluate((line) => getComputedStyle(line).backgroundColor);+ .evaluate((line) => getComputedStyle(line).stroke);const restingLine = await lineColor(groupRail);- /** A row two folds deep lights both rails down to it: the group's turns into- * the row's glyph, the phase's runs on past the group's header. */+ /** A row two folds deep lights both rails, each into its own branch: the+ * group's into the row's glyph, the phase's into the group's header. */const failedCall = groupPanel.getByTestId('tool-call').filter({ hasText: /^Failed:/ });- const litLength = (railLocator: typeof groupRail) =>- railLocator.evaluate((rail) => parseFloat(rail.style.getPropertyValue('--fold-lit')));+ const litBranch = (railLocator: typeof groupRail) =>+ railLocator.locator('[data-fold-trace][data-lit]');+ const endsAt = async (path: ReturnType<typeof litBranch>, row: typeof failedCall) => {+ await expect(path).toHaveCSS('opacity', '1');+ /** The foot slides into place, and branches are re-measured after rows move. */+ await expect+ .poll(async () => {+ const [elbow, glyph] = await Promise.all([+ path.boundingBox(),+ row.locator('.fold-glyph').first().boundingBox(),+ ]);+ return elbow == null || glyph == null+ ? Infinity+ : Math.abs(elbow.y + elbow.height - (glyph.y + glyph.height / 2));+ })+ .toBeLessThan(2);+ };await failedCall.scrollIntoViewIfNeeded();await failedCall.hover();- await expect(groupRail).toHaveAttribute('data-fold-lit', 'end');- await expect(phaseRail).toHaveAttribute('data-fold-lit', 'through');- expect(await litLength(phaseRail)).toBeGreaterThan(await litLength(groupRail));- const groupPath = groupRail.getByTestId('fold-rail-path');- await expect(groupPath).toHaveCSS('opacity', '1');- const [elbow, glyph] = await Promise.all([- groupPath.boundingBox(),- failedCall.locator('.fold-glyph').first().boundingBox(),- ]);- expect(elbow).not.toBeNull();- expect(glyph).not.toBeNull();- expect(Math.abs(elbow!.y + elbow!.height - (glyph!.y + glyph!.height / 2))).toBeLessThan(2);+ await expect(groupRail).toHaveAttribute('data-fold-lit');+ await expect(phaseRail).toHaveAttribute('data-fold-lit');+ await expect(litBranch(groupRail)).toHaveCount(1);+ await expect(litBranch(phaseRail)).toHaveCount(1);+ await endsAt(litBranch(groupRail), failedCall);+ await endsAt(litBranch(phaseRail), groupHeader);await shot(page, 'lit-path');await failedCall.evaluate((row) => {@@ -192,16 +201,16 @@ test.describe('activity fold', () => {row.dispatchEvent(new PointerEvent('pointerdown', { ...pointer, buttons: 1 }));row.dispatchEvent(new PointerEvent('pointerup', pointer));});- await expect(groupRail).not.toHaveAttribute('data-fold-lit');- await expect(phaseRail).not.toHaveAttribute('data-fold-lit');- await failedCall.scrollIntoViewIfNeeded();- await failedCall.hover();- await expect(groupRail).toHaveAttribute('data-fold-lit', 'end');+ /** A press keeps the path, hit-tested again under the pointer that did not move. */+ await expect(groupRail).toHaveAttribute('data-fold-lit');+ await expect(phaseRail).toHaveAttribute('data-fold-lit');+ await endsAt(litBranch(groupRail), failedCall);+ /** Rows moving under a still pointer relight from the new geometry. */await groupPanel.locator('> div > div').evaluate((rows) => {(rows as HTMLElement).style.paddingTop = '12px';});- await expect(groupRail).not.toHaveAttribute('data-fold-lit');- await expect(phaseRail).not.toHaveAttribute('data-fold-lit');+ await expect(groupRail).toHaveAttribute('data-fold-lit');+ await endsAt(litBranch(groupRail), failedCall);await groupPanel.locator('> div > div').evaluate((rows) => {(rows as HTMLElement).style.removeProperty('padding-top');});@@ -223,7 +232,7 @@ test.describe('activity fold', () => {});await failedCall.scrollIntoViewIfNeeded();await failedCall.hover();- await expect(groupRail).toHaveAttribute('data-fold-lit', 'end');+ await expect(groupRail).toHaveAttribute('data-fold-lit');const shift = await failedCall.evaluate((row) => {const fold = row.closest<HTMLElement>('[data-testid="activity-phase-card"]')!;const message = row.closest<HTMLElement>('.message-render')!;@@ -242,8 +251,10 @@ test.describe('activity fold', () => {expect(shift.after.foldHeight).toBe(shift.before.foldHeight);expect(shift.after.messageHeight).toBe(shift.before.messageHeight);expect(shift.after.scrollTop).toBe(shift.before.scrollTop);+ /** 32px further down, the pointer is over the group's header: the path is hit-tested+ * again and now ends in that header's branch of the phase. */await expect(groupRail).not.toHaveAttribute('data-fold-lit');- await expect(phaseRail).not.toHaveAttribute('data-fold-lit');+ await endsAt(litBranch(phaseRail), groupHeader);await transcript.evaluate((content, anchor) => {content.querySelector('#fold-layout-predecessor')!.remove();content.closest<HTMLElement>('.scrollbar-gutter-stable')!.style.overflowAnchor = anchor;diff --git a/e2e/specs/mock/scenarios/fold-tree.spec.ts b/e2e/specs/mock/scenarios/fold-tree.spec.tsnew file mode 100644index 0000000000..45a04e3c6e--- /dev/null+++ b/e2e/specs/mock/scenarios/fold-tree.spec.ts@@ -0,0 +1,381 @@+import { expect, test } from '@playwright/test';+import type { Locator, Page, Route } from '@playwright/test';+import { messagesView } from '../helpers';++/**+ * An open tool fold draws its rail as a tree: a trunk under the header's glyph with a+ * curved branch into each of its rows. Hovering a row lights the route along that tree,+ * from the header into the row, and the route only ever travels the drawn branches.+ * Conversations are routed fixtures, so every run sees the same rows.+ */+test.describe.configure({ timeout: 120_000 });++const NO_PARENT = '00000000-0000-0000-0000-000000000000';+const DESKTOP = { viewport: { width: 1280, height: 900 }, isMobile: false, hasTouch: false };+const unique = (prefix: string) => `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;+const escapeRe = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');++type Part = Record<string, unknown>;++const call = (id: string, name: string, args: Record<string, string>, output: string): Part => ({+ type: 'tool_call',+ tool_call: { id, name, args: JSON.stringify(args), output, progress: 1, type: 'tool_call' },+});++/** Four finished calls in one batch: a single tool group with four rows. */+const GROUP_CONTENT: Part[] = [+ call('g1', 'edit_file_mcp_filesystem', { path: 'src/config.ts' }, 'Edited src/config.ts'),+ call('g2', 'run_command_mcp_shell', { command: 'npm test -- config' }, 'PASS config.test.ts'),+ call('g3', 'run_command_mcp_shell', { command: 'npm test' }, 'Tests: 148 passed'),+ call('g4', 'run_command_mcp_shell', { command: 'git diff --stat' }, '1 file changed'),+ { type: 'text', text: 'Fold tree fixture done.' },+];++/** A phase over two labeled batches: tool groups nested inside an activity phase. */+const PHASE_CONTENT: Part[] = [+ call('p1', 'read_file_mcp_filesystem', { path: 'ci.yml' }, 'name: CI'),+ call('p2', 'read_file_mcp_filesystem', { path: 'package.json' }, '{ "name": "app" }'),+ call('p3', 'list_directory_mcp_filesystem', { path: 'src' }, 'index.ts'),+ {+ type: 'activity_label',+ activity_label: 'Read the build config',+ tool_call_ids: ['p1', 'p2', 'p3'],+ status: 'ok',+ },+ call('p4', 'run_command_mcp_shell', { command: 'npm test' }, 'PASS'),+ call('p5', 'read_file_mcp_filesystem', { path: 'src/config.ts' }, 'export const PORT = 3080;'),+ {+ type: 'activity_label',+ activity_label: 'Ran the test suite',+ tool_call_ids: ['p4', 'p5'],+ status: 'ok',+ },+ {+ type: 'activity_label',+ activity_label: 'Investigated the build',+ activity_label_type: 'phase',+ activity_start_index: 0,+ activity_end_index: 7,+ activity_count: 5,+ status: 'ok',+ pending: false,+ },+ { type: 'text', text: 'Fold tree fixture done.' },+];++async function routeConversation(page: Page, content: Part[]): Promise<string> {+ const conversationId = unique('e2e-fold-tree');+ const now = new Date(0).toISOString();+ const message = {+ messageId: `${conversationId}-msg`,+ conversationId,+ parentMessageId: NO_PARENT,+ isCreatedByUser: false,+ sender: 'Assistant',+ endpoint: 'Mock Provider A',+ model: 'mock-model-a',+ text: '',+ content,+ createdAt: now,+ updatedAt: now,+ };+ const conversation = {+ conversationId,+ title: 'Fold tree',+ endpoint: 'Mock Provider A',+ endpointType: 'custom',+ model: 'mock-model-a',+ createdAt: now,+ updatedAt: now,+ };+ const convoIdRe = escapeRe(conversationId);+ await page.route(new RegExp(`/api/convos/${convoIdRe}(?:\\?.*)?$`), (route: Route) =>+ route.fulfill({+ status: 200,+ contentType: 'application/json',+ body: JSON.stringify(conversation),+ }),+ );+ await page.route(new RegExp(`/api/messages/${convoIdRe}(?:\\?.*)?$`), (route: Route) =>+ route.fulfill({+ status: 200,+ contentType: 'application/json',+ body: JSON.stringify([message]),+ }),+ );+ return conversationId;+}++async function openConversation(page: Page, content: Part[]) {+ const conversationId = await routeConversation(page, content);+ await page.goto(`/c/${conversationId}`, { timeout: 30000 });+ await expect(messagesView(page).getByText('Fold tree fixture done.')).toBeVisible({+ timeout: 20000,+ });+}++/** The panel of the tool group whose header reads `name`, opened if it is folded. */+async function openGroup(page: Page, name: RegExp): Promise<Locator> {+ const header = messagesView(page).getByRole('button', { name }).first();+ await expect(header).toBeVisible();+ if ((await header.getAttribute('aria-expanded')) !== 'true') {+ await header.click();+ }+ await expect(header).toHaveAttribute('aria-expanded', 'true');+ return messagesView(page)+ .getByTestId('tool-call-group-panel')+ .filter({ has: page.getByRole('button', { name: /^Ran / }) })+ .last();+}++const railOf = (panel: Locator) => panel.locator('> div > [data-testid="fold-rail"]');+const traceOf = (rail: Locator) => rail.locator('[data-fold-trace]');+const branchesOf = (rail: Locator) => rail.locator('[data-testid="fold-rail-tree"] > g > path');+const rowsOf = (panel: Locator) => panel.getByRole('button', { name: /^Ran / });++async function center(locator: Locator) {+ const box = await locator.boundingBox();+ expect(box).not.toBeNull();+ return { x: box!.x + box!.width / 2, y: box!.y + box!.height / 2, box: box! };+}++/** The lit route ends in `row`: the bottom of its bounding box sits on the row glyph's center. */+async function expectRouteEndsAt(rail: Locator, row: Locator) {+ const trace = traceOf(rail);+ await expect(trace).toHaveAttribute('data-lit', '');+ await expect+ .poll(async () => {+ const [path, glyph] = await Promise.all([+ trace.boundingBox(),+ row.locator('.fold-glyph').first().boundingBox(),+ ]);+ return path == null || glyph == null+ ? Infinity+ : Math.abs(path.y + path.height - (glyph.y + glyph.height / 2));+ })+ .toBeLessThan(2);+}++/**+ * Records the lit path's shape on every animation frame while `act` runs, in the rail's+ * own coordinates, alongside the branch points the rail drew (one radius above each+ * row center).+ */+async function sampleRoute(rail: Locator, act: () => Promise<void>, ms = 900) {+ await rail.evaluate((element, duration) => {+ const path = element.querySelector('[data-fold-trace]')!;+ const samples: string[] = [];+ (window as unknown as { __foldSamples: string[] }).__foldSamples = samples;+ const until = performance.now() + duration;+ const step = () => {+ samples.push(path.getAttribute('d') ?? '');+ if (performance.now() < until) {+ requestAnimationFrame(step);+ }+ };+ requestAnimationFrame(step);+ }, ms);+ await act();+ await rail.page().waitForTimeout(ms + 100);+ return rail.evaluate((element) => ({+ samples: (window as unknown as { __foldSamples: string[] }).__foldSamples,+ centers: (element.getAttribute('data-centers') ?? '').split(',').map(Number),+ }));+}++const tipOf = (d: string) => Number(/V ([\d.]+)/.exec(d)?.[1]);+const hasBranch = (d: string) => d.includes(' A ');++test.describe('tool fold tree (pointer)', () => {+ test.use(DESKTOP);++ test('an open tool fold draws a branch into each of its rows @scenario:open-tool-fold-branches-into-each-row', async ({+ page,+ }) => {+ await openConversation(page, GROUP_CONTENT);+ const panel = await openGroup(page, /^Ran 4 actions/);+ const rail = railOf(panel);+ const rows = rowsOf(panel);+ await expect(rows).toHaveCount(4);+ /** The trunk, then one branch per row. */+ await expect(branchesOf(rail)).toHaveCount(5);+ for (let i = 0; i < 4; i++) {+ const [branch, glyph] = await Promise.all([+ branchesOf(rail)+ .nth(i + 1)+ .boundingBox(),+ rows.nth(i).locator('.fold-glyph').first().boundingBox(),+ ]);+ expect(Math.abs(branch!.y + branch!.height - (glyph!.y + glyph!.height / 2))).toBeLessThan(2);+ /** The branch stops short of the row's icon rather than running under it. */+ expect(branch!.x + branch!.width).toBeLessThanOrEqual(glyph!.x + 2);+ }+ /** The trunk hangs from the header glyph's axis. */+ const header = messagesView(page)+ .getByRole('button', { name: /^Ran 4 actions/ })+ .first();+ const trunk = await center(branchesOf(rail).first());+ const headerGlyph = await center(header.locator('.fold-glyph').first());+ expect(Math.abs(trunk.x - headerGlyph.x)).toBeLessThan(2);+ await expect(rail).toHaveAttribute('aria-hidden', 'true');+ await expect(rail).toHaveAttribute('tabindex', '-1');+ });++ test('hovering a row lights the route from the header into that row @scenario:hovered-tool-row-lights-route-from-header', async ({+ page,+ }) => {+ await openConversation(page, GROUP_CONTENT);+ const panel = await openGroup(page, /^Ran 4 actions/);+ const rail = railOf(panel);+ const rows = rowsOf(panel);+ await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');+ await rows.nth(2).hover();+ await expect(rail).toHaveAttribute('data-fold-lit', '2');+ await expectRouteEndsAt(rail, rows.nth(2));+ /** Leaving the fold fades the route out. */+ await page.mouse.move(5, 5);+ await expect(rail).not.toHaveAttribute('data-fold-lit');+ await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');+ await expect(traceOf(rail)).toHaveCSS('opacity', '0');+ });++ test('a row in a nested fold lights every level into its own branch @scenario:nested-fold-row-lights-each-level', async ({+ page,+ }) => {+ await openConversation(page, PHASE_CONTENT);+ const phaseHeader = messagesView(page).getByRole('button', { name: 'Investigated the build' });+ await phaseHeader.click();+ await expect(phaseHeader).toHaveAttribute('aria-expanded', 'true');+ const phaseRail = messagesView(page)+ .getByTestId('activity-phase-panel')+ .locator('> div > [data-testid="fold-rail"]');+ const groupHeader = messagesView(page).getByRole('button', { name: /^Ran the test suite/ });+ const panel = await openGroup(page, /^Ran the test suite/);+ const groupRail = railOf(panel);+ const row = rowsOf(panel).first();+ await row.hover();+ await expectRouteEndsAt(groupRail, row);+ /** The phase lights its branch into the group's header, which leads on into the row. */+ await expectRouteEndsAt(phaseRail, groupHeader);+ });++ test('moving between rows travels the tree, never cutting across it @scenario:lit-route-travels-tree-between-rows', async ({+ page,+ }) => {+ await openConversation(page, GROUP_CONTENT);+ const panel = await openGroup(page, /^Ran 4 actions/);+ const rail = railOf(panel);+ const rows = rowsOf(panel);+ await rows.nth(2).hover();+ await expectRouteEndsAt(rail, rows.nth(2));++ const { samples, centers } = await sampleRoute(rail, () => rows.nth(1).hover());+ const from = centers[2] - 8;+ const to = centers[1] - 8;+ const moving = samples.filter((d) => d !== '');+ expect(moving.length).toBeGreaterThan(3);+ for (let i = 0; i < moving.length; i++) {+ const tip = tipOf(moving[i]);+ /** Only the trunk between the two rows: never above the new row, never via the top. */+ expect(tip).toBeGreaterThanOrEqual(to - 0.5);+ expect(tip).toBeLessThanOrEqual(from + 0.5);+ if (i > 0) {+ expect(tip).toBeLessThanOrEqual(tipOf(moving[i - 1]) + 0.5);+ }+ /** A branch is drawn only from a branch point, so nothing leaves the tree. */+ if (hasBranch(moving[i])) {+ expect(Math.min(Math.abs(tip - from), Math.abs(tip - to))).toBeLessThan(0.5);+ }+ }+ expect(moving.some((d) => !hasBranch(d) && tipOf(d) > to + 1 && tipOf(d) < from - 1)).toBe(+ true,+ );+ await expectRouteEndsAt(rail, rows.nth(1));+ });++ test('the route stays lit through a click that unfolds the hovered row @scenario:lit-route-stays-after-click-folds-rows', async ({+ page,+ }) => {+ await openConversation(page, GROUP_CONTENT);+ const panel = await openGroup(page, /^Ran 4 actions/);+ const rail = railOf(panel);+ const rows = rowsOf(panel);+ await rows.nth(1).hover();+ await expectRouteEndsAt(rail, rows.nth(1));+ /** Click without moving the pointer: the row opens and the rows below it move. */+ await page.mouse.down();+ await page.mouse.up();+ await expect(rows.nth(1)).toHaveAttribute('aria-expanded', 'true');+ await expect(rail).toHaveAttribute('data-fold-lit', '1');+ await expectRouteEndsAt(rail, rows.nth(1));+ /** And again to fold it: still lit, still ending in the same row. */+ await page.mouse.down();+ await page.mouse.up();+ await expect(rows.nth(1)).toHaveAttribute('aria-expanded', 'false');+ await expectRouteEndsAt(rail, rows.nth(1));+ });++ test('with reduced motion the route is placed at once @scenario:reduced-motion-places-lit-route-at-once', async ({+ page,+ }) => {+ await page.emulateMedia({ reducedMotion: 'reduce' });+ await openConversation(page, GROUP_CONTENT);+ const panel = await openGroup(page, /^Ran 4 actions/);+ const rail = railOf(panel);+ const rows = rowsOf(panel);+ await rows.nth(0).hover();+ await expectRouteEndsAt(rail, rows.nth(0));+ const { samples } = await sampleRoute(rail, () => rows.nth(3).hover(), 500);+ /** The shape for the first row, then the shape for the last row, and nothing between. */+ expect(new Set(samples.filter((d) => d !== '')).size).toBeLessThanOrEqual(2);+ await expectRouteEndsAt(rail, rows.nth(3));+ });++ test('a right-to-left locale mirrors the tree toward its rows @scenario:rtl-tool-tree-mirrors-branches', async ({+ page,+ }) => {+ await page.addInitScript(() => localStorage.setItem('lang', JSON.stringify('ar')));+ await openConversation(page, GROUP_CONTENT);+ await expect(page.locator('html')).toHaveAttribute('dir', 'rtl', { timeout: 30000 });+ const panel = messagesView(page).getByTestId('tool-call-group-panel').last();+ /** The copy is Arabic, so the header is found by its place right above the panel. */+ const header = panel.locator('xpath=preceding-sibling::div[1]').getByRole('button').first();+ await header.click();+ await expect(header).toHaveAttribute('aria-expanded', 'true');+ const rail = railOf(panel);+ const row = panel.locator('.fold-glyph').nth(1);+ const branch = branchesOf(rail).nth(2);+ const [path, glyph, trunk] = await Promise.all([+ branch.boundingBox(),+ row.boundingBox(),+ branchesOf(rail).first().boundingBox(),+ ]);+ /** The trunk sits to the row's right, and the branch runs leftward from it to the row. */+ expect(trunk!.x).toBeGreaterThan(glyph!.x + glyph!.width);+ expect(path!.x).toBeGreaterThanOrEqual(glyph!.x + glyph!.width - 2);+ expect(Math.abs(path!.x + path!.width - (trunk!.x + trunk!.width / 2))).toBeLessThan(2);+ expect(Math.abs(path!.y + path!.height - (glyph!.y + glyph!.height / 2))).toBeLessThan(2);+ });+});++test.describe('tool fold tree (touch)', () => {+ test.use({ viewport: { width: 390, height: 844 }, isMobile: true, hasTouch: true });++ test('tapping a row leaves the tree dark @scenario:touch-tap-leaves-tool-tree-dark', async ({+ page,+ }) => {+ await openConversation(page, GROUP_CONTENT);+ const header = messagesView(page)+ .getByRole('button', { name: /^Ran 4 actions/ })+ .first();+ await header.tap();+ await expect(header).toHaveAttribute('aria-expanded', 'true');+ const panel = messagesView(page).getByTestId('tool-call-group-panel').last();+ const rail = railOf(panel);+ await expect(branchesOf(rail)).toHaveCount(5);+ await rowsOf(panel).nth(1).tap();+ await expect(rowsOf(panel).nth(1)).toHaveAttribute('aria-expanded', 'true');+ await expect(rail).not.toHaveAttribute('data-fold-lit');+ await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');+ });+});