* 📜 style: Scroll the Sidebar as One Surface
Projects, Pinned and the chats list each owned a scroll pane, so only the
chats list scrolled while the sections above it stayed pinned. The sidebar
now has one scroll viewport holding all three: the virtualized chats list
renders at its natural height and is windowed by that viewport instead of
scrolling itself.
`useOuterScrollWindow` translates the viewport's scroll position into the
list's coordinates. It re-measures on scroll and observes both the viewport
and the content wrapper, because a section collapsing above the list moves
the list without resizing either the viewport or the list.
* 🧪 test: Cover the Sidebar's Single Scroll Surface
Four scenarios in the mock harness: the whole sidebar rides one wheel
gesture, older chats keep loading as it reaches its end, collapsing a
section above the chats leaves the visible rows painted, and a long
pinned list scrolls with the sidebar instead of inside its own box.
The chat list grid no longer matches its container's height — it renders
at the height of the rows it holds — so the width-tracking spec measures
width alone and seeds the rows it measures.
* 🪟 fix: Keep the Windowed List Honest Without ResizeObserver
A section collapsing above the chats list moves it without resizing the
viewport or the list and without a scroll event. Where ResizeObserver is
missing, the fallback only listened for window resizes, so the list kept
windowing against the old offset and could paint the wrong rows. It now
watches the content wrapper the same way the observer does: its mutations
and the bubbling transitionend of its height tween.
The hook gets its own spec — offset translation, clamping at the top,
frame coalescing, the collapse re-measure, the fallback trigger and
listener cleanup — and the scenario specs reach the drawer on emulated
touch devices, where the header's opener appears only once the chat has
rendered and a wheel gesture is not what a person produces.
* 👁️ fix: Window the Chats List on What the Reader Can See
The list was handed the whole sidebar's height as its window, so with a
screenful of projects or pins above it, react-virtualized counted a
viewport of chat rows as rendered at the top of the list and the
eight-row pagination threshold was crossed before a single chat had been
exposed — a second conversations request nobody had asked for, on the
load path the Lighthouse lane guards. The window is now the slice of the
list the viewport actually shows: zero while it is below the fold, the
viewport's height once it fills it.
Searching also kept the shared surface's scroll position while replacing
what it held — Projects and Pinned leave and the chats become results —
so results long enough to escape the browser's clamp opened partway
down. The surface returns to the top whenever it swaps contents.
* 🧪 test: Seed the Pagination Scenario's Pins Out of the First Page
* 🧪 test: Claim the Settled Layout in the Pagination Scenario
* 🩹 fix: Keep a Pixel of Window So an Unseen List Can Be Reached
A list handed a zero window renders nothing, and react-virtualized only emits its inner container when it has children, so the list collapsed to no height and the surface had nothing to scroll toward: the chats below a screenful of pins could never be reached. The window keeps a single pixel, which renders the first row and restores the list's own height without claiming a screenful is on display.
* 🧪 test: Scroll Until the Chats List Answers
* 🚦 fix: Ask for Another Page Only Once the Chats Are in View
A list below the fold still renders its first row — that pixel of window
is what gives it a height to be scrolled to — and on a page whose chats
are nearly all pinned, that single row already sits inside the eight-row
threshold, so the list asked for another page before anyone had looked at
it. Reaching the end of what is rendered now counts only while the list
is on screen; the hook reports that separately from its height, and a
page holding no chats at all is still drained by the all-pin effect.
* 🔎 fix: Ask the Layout Whether the Chats Are in View
Visibility was a value sampled on a frame, and a commit that swaps what
the sidebar holds — leaving a search restores the sections and the
unfiltered page together — moves the list before any observer runs, so
rows reported during that commit were judged against the layout before
it. The hook now answers from the layout as it stands when asked, and
the pagination gate asks.
The header now branches on CSS instead of `useMediaQuery`, so its mobile
`OpenSidebar` stays mounted at every breakpoint. The sidebar rail already
publishes `open-sidebar-button` for its own collapsed toggle, so both held
the id at once and `getByTestId` resolved to two elements.
Scope the header's copy to `header-open-sidebar-button` and assert the count
in the spec that broke — the click there failed only once the header had
mounted, so a count assertion pins the collision deterministically.
* 🪟 fix: Re-measure sidebar chat list on width change to fix date-group spacing
When the sidebar is expanded from a collapsed reload, virtualized rows first
measure mid-animation at a narrow width, so date-group headers wrap and cache an
inflated height. CellMeasurerCache(fixedWidth) keys heights by row, not width, so
the stale height persists once full width is reached — leaving gaps under headers.
Invalidate the measurement cache and recompute row heights whenever the measured
list width changes. Adds a Playwright mock e2e (seeds backdated convos across date
groups via a new db helper) that fails without the fix and passes with it.
* 🧪 test: Harden sidebar e2e (runtime-env path, midnight-safe seed, convo isolation)
Addresses Codex review on PR #13981:
- db.ts honors E2E_RUNTIME_ENV_PATH when locating the runtime Mongo URI.
- Seed timestamps anchor on local noon so the Today group stays in-day near midnight.
- Clear the shared user's conversations before seeding so later date-group headers
are not pushed below the virtualized viewport by other specs' leftover chats.