Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix([issue-11608]): keep long Media History sessions responsive (#11628)

[._.]/c1c91845bf76
diff --git a/client/src/components/media/MediaHistoryGrid.jsx b/client/src/components/media/MediaHistoryGrid.jsx
new file mode 100644
index 0000000000..b201e8441a
--- /dev/null
+++ b/client/src/components/media/MediaHistoryGrid.jsx
@@ -0,0 +1,134 @@
+import { useLayoutEffect, useMemo, useRef, useState } from 'react';
+
+const OVERSCAN_ROWS = 2;
+const GAP = 12;
+
+/** A measured row window: loaded records stay in the page, cards stay near the viewport. */
+export default function MediaHistoryGrid({ items, children }) {
+ const rootRef = useRef(null);
+ const heights = useRef(new Map());
+ const previousGeometry = useRef(null);
+ const restoreFocus = useRef(null);
+ const scrollerRef = useRef(null);
+ const [layout, setLayout] = useState({ columns: 2, width: 0, top: 0, height: 800, revision: 0 });
+ const [focusedKey, setFocusedKey] = useState(null);
+ const rows = Math.ceil(items.length / layout.columns);
+ const estimate = layout.width ? (layout.width - GAP * (layout.columns - 1)) / layout.columns + 270 : 460;
+ const rowKeys = useMemo(() => Array.from({ length: rows }, (_, row) => items.slice(row * layout.columns, (row + 1) * layout.columns).map(item => item.key)), [items, rows, layout.columns]);
+ const offsets = useMemo(() => {
+ const values = [0];
+ for (let row = 0; row < rows; row++) values.push(values[row] + Math.max(...rowKeys[row].map(key => heights.current.get(key) ?? estimate)) + GAP);
+ return values;
+ }, [rows, rowKeys, estimate, layout.revision]);
+
+ useLayoutEffect(() => {
+ const root = rootRef.current;
+ let scroller = root.parentElement;
+ while (scroller && !/(auto|scroll)/.test(getComputedStyle(scroller).overflowY)) scroller = scroller.parentElement;
+ scrollerRef.current = scroller;
+ const scrollTarget = scroller || window;
+ let frame;
+ const measure = () => {
+ const rect = root.getBoundingClientRect();
+ const view = scroller?.getBoundingClientRect();
+ const columns = getComputedStyle(root).gridTemplateColumns.split(' ').filter(Boolean).length || 2;
+ const width = rect.width;
+ setLayout(previous => {
+ const resized = previous.width !== width || previous.columns !== columns;
+ if (resized) heights.current.clear();
+ const next = { columns, width, top: (view?.top || 0) - rect.top, height: scroller?.clientHeight || window.innerHeight,
+ revision: previous.revision + (resized ? 1 : 0) };
+ return Object.keys(next).every(key => next[key] === previous[key]) ? previous : next;
+ });
+ };
+ const schedule = () => {
+ cancelAnimationFrame(frame);
+ frame = requestAnimationFrame(measure);
+ };
+ const observer = new ResizeObserver(schedule);
+ observer.observe(root);
+ if (scroller) observer.observe(scroller);
+ scrollTarget.addEventListener('scroll', schedule, { passive: true });
+ window.addEventListener('resize', schedule);
+ measure();
+ return () => {
+ observer.disconnect();
+ cancelAnimationFrame(frame);
+ scrollTarget.removeEventListener('scroll', schedule);
+ window.removeEventListener('resize', schedule);
+ };
+ }, []);
+
+ useLayoutEffect(() => {
+ const keys = new Set(items.map(item => item.key));
+ for (const key of heights.current.keys()) if (!keys.has(key)) heights.current.delete(key);
+ const observer = new ResizeObserver(entries => {
+ let changed = false;
+ for (const { target } of entries) {
+ const height = target.getBoundingClientRect().height;
+ if (height > 0 && heights.current.get(target.dataset.mediaKey) !== height) {
+ heights.current.set(target.dataset.mediaKey, height);
+ changed = true;
+ }
+ }
+ if (changed) setLayout(previous => ({ ...previous, revision: previous.revision + 1 }));
+ });
+ for (const row of rootRef.current.querySelectorAll('[data-media-key]')) observer.observe(row);
+ return () => observer.disconnect();
+ });
+
+ useLayoutEffect(() => {
+ const previous = previousGeometry.current;
+ if (previous && previous.top === layout.top) {
+ let row = 0;
+ while (row < previous.offsets.length - 2 && previous.offsets[row + 1] < Math.max(0, previous.top)) row++;
+ const anchor = previous.items[row * previous.columns]?.key;
+ const index = items.findIndex(item => item.key === anchor);
+ if (index !== -1) {
+ const delta = offsets[Math.floor(index / layout.columns)] - previous.offsets[row];
+ if (delta) {
+ if (scrollerRef.current) scrollerRef.current.scrollTop += delta;
+ else window.scrollBy(0, delta);
+ setLayout(value => ({ ...value, top: value.top + delta }));
+ }
+ }
+ }
+ previousGeometry.current = { items, offsets, top: layout.top, columns: layout.columns };
+ const focus = restoreFocus.current;
+ if (focus && !focus.element.isConnected && [document.body, rootRef.current].includes(document.activeElement)) {
+ const card = [...rootRef.current.querySelectorAll('[data-media-key]')].find(element => element.dataset.mediaKey === focus.key);
+ const control = card?.querySelectorAll('button, a, input, select, textarea')[focus.control];
+ restoreFocus.current = null;
+ (control || rootRef.current).focus({ preventScroll: true });
+ }
+ }, [items, offsets, layout.top, layout.columns]);
+
+ let first = 0;
+ while (first < rows - 1 && offsets[first + 1] < layout.top) first++;
+ let last = first;
+ while (last < rows - 1 && offsets[last] < layout.top + layout.height) last++;
+ const mounted = new Set();
+ for (let row = Math.max(0, first - OVERSCAN_ROWS); row <= Math.min(rows - 1, last + OVERSCAN_ROWS); row++) mounted.add(row);
+ const focusedIndex = items.findIndex(item => item.key === focusedKey);
+ if (focusedIndex !== -1) {
+ const focusedRow = Math.floor(focusedIndex / layout.columns);
+ // Neighbors let native Tab / Shift+Tab enter the next row even after scrolling away.
+ for (let row = Math.max(0, focusedRow - 1); row <= Math.min(rows - 1, focusedRow + 1); row++) mounted.add(row);
+ }
+ const cardWidth = Math.max(0, (layout.width - GAP * (layout.columns - 1)) / layout.columns);
+ return <div ref={rootRef} tabIndex={-1} data-media-history-grid data-loaded-items={items.length} data-window-start={first} data-columns={layout.columns} data-overscan-rows={OVERSCAN_ROWS}
+ className="relative grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5"
+ style={{ columnGap: GAP, height: Math.max(0, offsets[rows] - GAP), overflowAnchor: 'none' }}
+ onBlurCapture={event => { if (!event.currentTarget.contains(event.relatedTarget)) { setFocusedKey(null); restoreFocus.current = null; } }}>
+ {items.flatMap((item, index) => {
+ const row = Math.floor(index / layout.columns);
+ if (!mounted.has(row)) return [];
+ return <div key={item.key} data-media-key={item.key} data-media-row={row} className="absolute min-w-0"
+ style={{ top: offsets[row], left: (index % layout.columns) * (cardWidth + GAP), width: cardWidth || '100%' }}
+ onFocusCapture={event => {
+ setFocusedKey(item.key);
+ restoreFocus.current = { element: event.target, key: item.key, control: [...event.currentTarget.querySelectorAll('button, a, input, select, textarea')].indexOf(event.target) };
+ }}>{children(item)}</div>;
+ })}
+ </div>;
+}
diff --git a/client/src/components/media/MediaHistoryGrid.test.jsx b/client/src/components/media/MediaHistoryGrid.test.jsx
new file mode 100644
index 0000000000..5b521799b9
--- /dev/null
+++ b/client/src/components/media/MediaHistoryGrid.test.jsx
@@ -0,0 +1,82 @@
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import MediaHistoryGrid from './MediaHistoryGrid';
+
+let columns;
+let width;
+let observers;
+const items = Array.from({ length: 1200 }, (_, n) => ({ key: `image:${n}` }));
+const rect = (top, height, rectWidth) => ({ top, bottom: top + height, left: 0, right: rectWidth, width: rectWidth, height, x: 0, y: top });
+beforeEach(() => {
+ columns = 5; width = 1000; observers = [];
+ const computed = window.getComputedStyle.bind(window);
+ vi.spyOn(window, 'getComputedStyle').mockImplementation(element => element.hasAttribute('data-media-history-grid')
+ ? { gridTemplateColumns: Array(columns).fill(`${width / columns}px`).join(' ') } : computed(element));
+ vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function () {
+ if (this.hasAttribute('data-media-history-grid')) return rect(100 - this.parentElement.scrollTop, 10000, width);
+ if (this.hasAttribute('data-media-row')) return rect(0, 200, width);
+ return rect(0, 600, width);
+ });
+ vi.stubGlobal('ResizeObserver', vi.fn(function (callback) {
+ const targets = new Set();
+ this.observe = element => targets.add(element);
+ this.disconnect = () => targets.clear();
+ observers.push(() => callback([...targets].map(target => ({ target }))));
+ }));
+});
+afterEach(() => { vi.restoreAllMocks(); vi.unstubAllGlobals(); });
+const notify = () => act(() => { for (const observer of [...observers]) observer(); });
+const card = item => <><button type="button">{item.key}</button><input aria-label={`Draft ${item.key}`} /></>;
+
+it('bounds mounted rows across a long scroll, pins keyboard focus, and returns to the first row', async () => {
+ const { container } = render(<main style={{ overflowY: 'auto' }}><MediaHistoryGrid items={items}>{card}</MediaHistoryGrid></main>);
+ const main = container.firstChild;
+ Object.defineProperty(main, 'clientHeight', { configurable: true, value: 600 });
+ notify();
+ expect(screen.getAllByRole('button').length).toBeLessThanOrEqual(60);
+ act(() => screen.getByText('image:0').focus());
+ main.scrollTop = 50000;
+ fireEvent.scroll(main);
+ await waitFor(() => expect(container.querySelector('[data-media-row="0"]')).toBeInTheDocument());
+ await waitFor(() => expect(Number(container.querySelector('[data-media-history-grid]').dataset.windowStart)).toBeGreaterThan(50));
+ expect(document.activeElement).toHaveTextContent('image:0');
+ expect(screen.getAllByRole('button').length).toBeLessThanOrEqual(60);
+ act(() => document.activeElement.blur());
+ await waitFor(() => expect(screen.queryByText('image:0')).toBeNull());
+ main.scrollTop = 0;
+ fireEvent.scroll(main);
+ await screen.findByText('image:0');
+ expect(screen.getAllByRole('button').length).toBeLessThanOrEqual(60);
+});
+
+it('keeps the visible anchor through responsive regrouping and earlier-record deletion', async () => {
+ const view = rows => <main style={{ overflowY: 'auto' }}><MediaHistoryGrid items={rows}>{card}</MediaHistoryGrid></main>;
+ const { container, rerender } = render(view(items));
+ const main = container.firstChild;
+ Object.defineProperty(main, 'clientHeight', { configurable: true, value: 600 });
+ notify();
+ main.scrollTop = 10000;
+ fireEvent.scroll(main);
+ await waitFor(() => expect(Number(container.querySelector('[data-media-history-grid]').dataset.windowStart)).toBeGreaterThan(10));
+ const before = Number(container.querySelector('[data-media-history-grid]').dataset.windowStart) * 5;
+ columns = 2; width = 500;
+ fireEvent(window, new Event('resize'));
+ await waitFor(() => expect(container.querySelector('[data-media-history-grid]').dataset.columns).toBe('2'));
+ await waitFor(() => expect(container.querySelector(`[data-media-key="image:${before}"]`)).toBeInTheDocument());
+ expect(screen.getAllByRole('button').length).toBeLessThanOrEqual(24);
+ rerender(view(items.slice(1)));
+ await waitFor(() => expect(container.querySelector(`[data-media-key="image:${before}"]`)).toBeInTheDocument());
+});
+
+it('retains a focused boundary card across a prepend and does not reclaim deliberately moved focus', () => {
+ const view = rows => <><MediaHistoryGrid items={rows}>{card}</MediaHistoryGrid><button type="button">Outside</button></>;
+ const { rerender } = render(view(items));
+ fireEvent.change(screen.getByLabelText('Draft image:4'), { target: { value: 'Unsaved collection' } });
+ act(() => screen.getByText('image:4').focus());
+ rerender(view([{ key: 'image:new' }, ...items]));
+ expect(document.activeElement).toHaveTextContent('image:4');
+ expect(screen.getByLabelText('Draft image:4')).toHaveValue('Unsaved collection');
+ act(() => screen.getByText('Outside').focus());
+ rerender(view(items));
+ expect(document.activeElement).toHaveTextContent('Outside');
+});
diff --git a/client/src/hooks/README.md b/client/src/hooks/README.md
index 2f89256acd..be6132178b 100644
--- a/client/src/hooks/README.md
+++ b/client/src/hooks/README.md
@@ -295,7 +295,7 @@ grep -i "what you want to do" client/src/hooks/README.md
| `useGalleryPreviewResolver` | Builds the stable `resolveItem` callback that resolves a `?preview=` param the host's own items list does not contain, by looking the record up in the gallery and normalizing it. `usePreviewRoute` uses it as its DEFAULT. | Call it directly only to narrow the lookup — `collectionId` scopes it to one collection. |
| `useGeneratedPreview` | One OS-isolated generated-preview session. Emits `generated-preview:open` for `request` and returns inert JPEG frames, seek/command functions, and a recording blob. Reconnect opens a fresh session with the current controls and playhead; idle/capacity closure returns `status: 'idle'` until the viewer calls `resume()`. Film-look and title-card `controls` ride the open and later commands. A revision change reopens; a control change does not. Unsupported hosts surface `status: 'unavailable'` and never fall back to an iframe. | Music-video composition, code-video, and code-animation previews. |
| `useImageVariants` | Fetches the original-vs-cleaned variant set for the one open image (`GET /api/image-gen/:filename/variants`), normalized; reuses the held group across toggle clicks and aborts a superseded lookup. `null` while unfetched or failed, `[]` when the image is not indexed. | `MediaPreview` calls it for every image preview; neither a page-owned ref list nor a 60-row gallery window is a complete source of variant lineage. |
-| `useGalleryPage` | Bounded image or mixed-media browsing with debounced server search, scopes, totals, stale-response cancellation and retryable next pages. | Gallery grids and pickers; `getGalleryImages` hydrates known references separately. |
+| `useGalleryPage` | Bounded image or mixed-media browsing with debounced server search, scopes, totals, stale-response cancellation and retryable next pages. `preserveLoadedOnRefresh` reloads the retained window in compact pages while keeping existing cards mounted. | Gallery grids and pickers; `getGalleryImages` hydrates known references separately. |
| `usePagedCollection` | `usePagedCollection(fetchPage, { enabled })` — bounded cursor pages, deduplication by id, single-flight loading, abort/stale-query protection, retry, reset, and local mutation via setItems; an optional `meta` returned by `fetchPage` is exposed as the latest page's response-level data. | Growing cursor-based collections; pair with `InfiniteScrollFooter`. |
| `useGoalOrganize` / `useGoalCreate` | Shared goal suggestion preview, explicit apply, and guarded create flows for both Goals views. | Goals List and Tree views. |
diff --git a/client/src/hooks/useGalleryPage.js b/client/src/hooks/useGalleryPage.js
index 4bd80ef641..beebc27c96 100644
--- a/client/src/hooks/useGalleryPage.js
+++ b/client/src/hooks/useGalleryPage.js
@@ -1,8 +1,8 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { listImageGalleryPage, listMediaGalleryPage } from '../services/apiImageVideo';
/** Server-filtered gallery windows. Failed next pages keep the last good page. */
-export function useGalleryPage(filters = {}, { enabled = true, media = false, revision = '', paused = false } = {}) {
+export function useGalleryPage(filters = {}, { enabled = true, media = false, revision = '', paused = false, preserveLoadedOnRefresh = false } = {}) {
const [query, setQuery] = useState(filters.q || '');
useEffect(() => {
const timer = setTimeout(() => setQuery(filters.q || ''), 250);
@@ -11,6 +11,7 @@ export function useGalleryPage(filters = {}, { enabled = true, media = false, re
const scope = JSON.stringify({ ...filters, q: query });
const resetScope = `${scope}:${revision}`;
const [pageScope, setPageScope] = useState(resetScope);
+ const [filterScope, setFilterScope] = useState(scope);
const [offset, setOffset] = useState(0);
const [nextOffset, setNextOffset] = useState(null);
const [items, setItems] = useState([]);
@@ -19,10 +20,21 @@ export function useGalleryPage(filters = {}, { enabled = true, media = false, re
const [loading, setLoading] = useState(enabled);
const [error, setError] = useState(null);
const [refreshKey, setRefreshKey] = useState(0);
+ const refreshLength = useRef(0);
+ const loadedLength = useRef(0);
+ const retainedItems = useRef([]);
+ retainedItems.current = items;
+ loadedLength.current = items.length;
if (pageScope !== resetScope) {
- setPageScope(resetScope); setOffset(0); setItems([]); setNextOffset(null);
+ const retain = preserveLoadedOnRefresh && filterScope === scope;
+ refreshLength.current = retain ? items.length : 0;
+ setPageScope(resetScope); setFilterScope(scope); setOffset(0);
+ if (!retain) { setItems([]); setNextOffset(null); }
}
- const refresh = useCallback(() => { setOffset(0); setRefreshKey(n => n + 1); }, []);
+ const refresh = useCallback(() => {
+ refreshLength.current = preserveLoadedOnRefresh ? loadedLength.current : 0;
+ setOffset(0); setRefreshKey(n => n + 1);
+ }, [preserveLoadedOnRefresh]);
const retry = useCallback(() => setRefreshKey(n => n + 1), []);
useEffect(() => {
if (!enabled) {
@@ -33,8 +45,26 @@ export function useGalleryPage(filters = {}, { enabled = true, media = false, re
let cancelled = false;
setLoading(true); setError(null);
const fetchPage = media ? listMediaGalleryPage : listImageGalleryPage;
- fetchPage({ limit: 60, ...JSON.parse(scope), offset }, { silent: true }).then(page => {
+ const read = async () => {
+ let page = await fetchPage({ limit: 60, ...JSON.parse(scope), offset }, { silent: true });
+ const combined = [...page.items];
+ const rowKey = row => media ? `${row.kind}:${row.kind === 'video' ? row.data.id : row.data.filename}` : row.filename;
+ const retained = new Set(retainedItems.current.map(rowKey));
+ const tail = retainedItems.current.at(-1);
+ const crossedBoundary = () => !tail || combined.some(row => rowKey(row) === rowKey(tail))
+ || (combined.some(row => retained.has(rowKey(row))) && !page.items.some(row => retained.has(rowKey(row))));
+ // Refresh the retained window in compact 60-record requests. Keep the old
+ // cards mounted until the complete replacement is ready, including on error.
+ while (!cancelled && offset === 0 && refreshLength.current > 0 && (combined.length < refreshLength.current || !crossedBoundary())
+ && combined.length < page.total && page.items.length) {
+ page = await fetchPage({ limit: 60, ...JSON.parse(scope), offset: combined.length }, { silent: true });
+ combined.push(...page.items);
+ }
+ return { ...page, items: combined, offset };
+ };
+ read().then(page => {
if (cancelled) return;
+ refreshLength.current = 0;
setItems(previous => {
const rows = offset === 0 ? [] : previous;
const key = row => media ? `${row.kind}:${row.kind === 'video' ? row.data.id : row.data.filename}` : row.filename;
@@ -51,8 +81,8 @@ export function useGalleryPage(filters = {}, { enabled = true, media = false, re
return () => { cancelled = true; };
}, [scope, offset, enabled, media, revision, paused, refreshKey]);
const loadMore = useCallback(() => {
- if (!loading && nextOffset !== null) setOffset(nextOffset);
- }, [loading, nextOffset]);
+ if (!loading && !paused && nextOffset !== null) setOffset(nextOffset);
+ }, [loading, paused, nextOffset]);
return useMemo(() => ({ items, setItems, total, setTotal, counts, loading, error,
hasMore: nextOffset !== null, loadMore, refresh, retry }),
[items, total, counts, loading, error, nextOffset, loadMore, refresh, retry]);
diff --git a/client/src/hooks/useGalleryPage.test.jsx b/client/src/hooks/useGalleryPage.test.jsx
index c41907e8e9..69ace41dfa 100644
--- a/client/src/hooks/useGalleryPage.test.jsx
+++ b/client/src/hooks/useGalleryPage.test.jsx
@@ -22,3 +22,83 @@ it('restarts favorites after annotation changes and discards an in-flight older
expect(result.current.items).toEqual([{ filename: 'still-starred.png' }]);
expect(fetchPage).toHaveBeenLastCalledWith(expect.objectContaining({ offset: 0 }), { silent: true });
});
+
+it('keeps a retained multi-page window during refresh failure and retries compact pages atomically', async () => {
+ let rows = Array.from({ length: 180 }, (_, n) => ({ filename: `${n}.png` }));
+ const respond = async ({ offset = 0, limit }) => ({ items: rows.slice(offset, offset + limit), total: rows.length, offset });
+ fetchPage.mockImplementation(respond);
+ const { result } = renderHook(() => useGalleryPage({ compact: true }, { preserveLoadedOnRefresh: true }));
+ await waitFor(() => expect(result.current.items).toHaveLength(60));
+ act(() => result.current.loadMore());
+ await waitFor(() => expect(result.current.items).toHaveLength(120));
+ rows = rows.slice(1);
+ fetchPage.mockImplementationOnce(respond).mockRejectedValueOnce(new Error('Second page offline'));
+ act(() => result.current.refresh());
+ await waitFor(() => expect(result.current.error).toBe('Second page offline'));
+ expect(result.current.items).toHaveLength(120);
+ expect(result.current.items[0].filename).toBe('0.png');
+ act(() => result.current.retry());
+ await waitFor(() => expect(result.current.items[0].filename).toBe('1.png'));
+ expect(result.current.items).toHaveLength(120);
+ expect(fetchPage.mock.calls.every(([request]) => request.limit === 60 && request.compact)).toBe(true);
+ act(() => result.current.loadMore());
+ await waitFor(() => expect(result.current.items).toHaveLength(179));
+ expect(result.current.items.at(-1).filename).toBe('179.png');
+});
+
+it('retains the prior tail when completion prepends a new record during a long session', async () => {
+ let rows = Array.from({ length: 180 }, (_, n) => ({ filename: `${n}.png` }));
+ fetchPage.mockImplementation(async ({ offset = 0, limit }) => ({ items: rows.slice(offset, offset + limit), total: rows.length, offset }));
+ const { result } = renderHook(() => useGalleryPage({}, { preserveLoadedOnRefresh: true }));
+ await waitFor(() => expect(result.current.items).toHaveLength(60));
+ act(() => result.current.loadMore());
+ await waitFor(() => expect(result.current.items).toHaveLength(120));
+ rows = [{ filename: 'new.png' }, ...rows.slice(0, -1)];
+ act(() => result.current.refresh());
+ await waitFor(() => expect(result.current.items[0].filename).toBe('new.png'));
+ expect(result.current.items.some(item => item.filename === '119.png')).toBe(true);
+ expect(fetchPage.mock.calls.every(([request]) => request.limit === 60)).toBe(true);
+});
+
+it('crosses an entirely new first page to retain the prior window and stops after a removed boundary', async () => {
+ let rows = Array.from({ length: 600 }, (_, n) => ({ filename: `${n}.png` }));
+ fetchPage.mockImplementation(async ({ offset = 0, limit }) => ({ items: rows.slice(offset, offset + limit), total: rows.length, offset }));
+ const { result } = renderHook(() => useGalleryPage({}, { preserveLoadedOnRefresh: true }));
+ await waitFor(() => expect(result.current.items).toHaveLength(60));
+ rows = [...Array.from({ length: 60 }, (_, n) => ({ filename: `new-${n}.png` })), ...rows];
+ act(() => result.current.refresh());
+ await waitFor(() => expect(result.current.items).toHaveLength(120));
+ expect(result.current.items.at(-1).filename).toBe('59.png');
+ rows = rows.filter(row => row.filename !== '59.png');
+ fetchPage.mockClear();
+ act(() => result.current.refresh());
+ await waitFor(() => expect(result.current.items.at(-1).filename).toBe('120.png'));
+ expect(fetchPage).toHaveBeenCalledTimes(3);
+ expect(result.current.hasMore).toBe(true);
+});
+
+
+it('refreshes a retained favorites window after annotations change while filter changes reset it', async () => {
+ let rows = Array.from({ length: 180 }, (_, n) => ({ filename: `${n}.png` }));
+ let finishFirst;
+ fetchPage.mockImplementation(async ({ offset = 0, limit }) => ({ items: rows.slice(offset, offset + limit), total: rows.length, offset }));
+ const { result, rerender } = renderHook(({ revision, starred, paused }) => useGalleryPage({ starred }, { revision, paused, preserveLoadedOnRefresh: true }),
+ { initialProps: { revision: 'before', starred: true, paused: false } });
+ await waitFor(() => expect(result.current.items).toHaveLength(60));
+ act(() => result.current.loadMore());
+ await waitFor(() => expect(result.current.items).toHaveLength(120));
+ rows = rows.slice(1);
+ rerender({ revision: 'after', starred: true, paused: true });
+ expect(result.current.items).toHaveLength(120);
+ act(() => result.current.loadMore());
+ fetchPage.mockImplementationOnce(() => new Promise(resolve => { finishFirst = resolve; }));
+ rerender({ revision: 'after', starred: true, paused: false });
+ await waitFor(() => expect(finishFirst).toBeTypeOf('function'));
+ expect(fetchPage).toHaveBeenLastCalledWith(expect.objectContaining({ offset: 0 }), { silent: true });
+ expect(result.current.items).toHaveLength(120);
+ await act(async () => finishFirst({ items: rows.slice(0, 60), total: rows.length, offset: 0 }));
+ await waitFor(() => expect(result.current.items[0].filename).toBe('1.png'));
+ expect(result.current.items).toHaveLength(120);
+ rerender({ revision: 'after', starred: false, paused: true });
+ expect(result.current.items).toEqual([]);
+});
diff --git a/client/src/pages/MediaHistory.jsx b/client/src/pages/MediaHistory.jsx
index c034d8b33e..a21b23b482 100644
--- a/client/src/pages/MediaHistory.jsx
+++ b/client/src/pages/MediaHistory.jsx
@@ -12,6 +12,7 @@ import { Combine, Image as ImageIcon, Film, Search, X } from 'lucide-react';
import PageSkeleton from '../components/ui/PageSkeleton';
import toast from '../components/ui/Toast';
import MediaCard from '../components/media/MediaCard';
+import MediaHistoryGrid from '../components/media/MediaHistoryGrid';
import MediaPreview from '../components/media/MediaPreview';
import VideoUpscaleDrawer from '../components/media/VideoUpscaleDrawer';
import FavoritesFilterChip from '../components/media/FavoritesFilterChip';
@@ -52,7 +53,7 @@ export default function MediaHistory() {
// negative prompt, settings — is read when a card is opened or handed to a
// generator, never for the whole page. Search and counts stay server-side
// over the full metadata.
- const page = useGalleryPage({ kind: filter, q: query, starred: favoritesOnly, summary: true, hidden: false, compact: true }, { media: true, revision: annotationRevision, paused: favoritesOnly && annotationSaves > 0 });
+ const page = useGalleryPage({ kind: filter, q: query, starred: favoritesOnly, summary: true, hidden: false, compact: true }, { media: true, preserveLoadedOnRefresh: true, revision: annotationRevision, paused: favoritesOnly && annotationSaves > 0 });
const { loading, counts, refresh } = page;
const items = useMemo(() => page.items.map(normalizeMediaRow), [page.items]);
const setItems = useCallback(updater => page.setItems(previous => {
@@ -61,7 +62,6 @@ export default function MediaHistory() {
return next.map(item => ({ kind: item.kind, data: { ...item.raw, prompt: item.prompt } }));
}), [page.setItems]);
const filtered = items;
- const visibleItems = items;
const [preview, setPreview] = useHydratedPreviewRoute(items);
useMediaCompletionRefresh({ onImageCompleted: refresh, onVideoCompleted: refresh });
@@ -223,8 +223,8 @@ export default function MediaHistory() {
</div>
) : (
<>
- <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 gap-3">
- {visibleItems.map((it) => {
+ <MediaHistoryGrid items={items}>
+ {(it) => {
const inStitch = stitchMode && it.kind === 'video';
const idx = inStitch ? selected.indexOf(it.id) : -1;
return (
@@ -249,8 +249,8 @@ export default function MediaHistory() {
onAnnotate={!stitchMode && it.kind === 'image' ? handleAnnotate : undefined}
/>
);
- })}
- </div>
+ }}
+ </MediaHistoryGrid>
<InfiniteScrollFooter hasMore={page.hasMore} loading={loading} error={page.error}
onLoadMore={page.error ? page.retry : page.loadMore} autoLoad={!stitchMode}
label={`Show more (${page.total - items.length} remaining)`} />
diff --git a/client/src/pages/MediaHistory.test.jsx b/client/src/pages/MediaHistory.test.jsx
index f2abdaa8ae..5ec85ae411 100644
--- a/client/src/pages/MediaHistory.test.jsx
+++ b/client/src/pages/MediaHistory.test.jsx
@@ -11,6 +11,7 @@ vi.mock('../hooks/useMediaPreviewActions', () => ({ default: () => ({}) }));
vi.mock('../components/media/VideoUpscaleDrawer', () => ({ default: () => null }));
vi.mock('../components/media/MediaPreview', () => ({ default: ({ preview }) => preview ? <div role="dialog">{preview.prompt}{preview.detailError && ' [details unavailable]'}</div> : null }));
vi.mock('../components/media/MediaCard', () => ({ default: ({ item, onDelete, onToggleStar, onPreview }) => <div><button type="button" onClick={() => onPreview(item)}>{item.prompt}</button><button type="button" onClick={() => onToggleStar(item)}>Favorite {item.filename}</button><button type="button" onClick={() => onDelete(item)}>Delete {item.filename}</button></div> }));
+vi.mock('../components/media/MediaHistoryGrid', () => ({ default: ({ items, children }) => <div>{items.map(children)}</div> }));
import MediaHistory from './MediaHistory';
let rows;
diff --git a/scripts/perf/README.md b/scripts/perf/README.md
index 6d419bd806..0ac660491a 100644
--- a/scripts/perf/README.md
+++ b/scripts/perf/README.md
@@ -105,7 +105,9 @@ npm run build
PGDATABASE=portos_test node scripts/perf/browserCollectionAudit.mjs /tmp/collection-audit.json
~~~
-`COLLECTION_AUDIT_BROWSER` optionally selects a Chromium executable. The audit
+`COLLECTION_AUDIT_BROWSER` optionally selects a Chromium executable.
+`COLLECTION_AUDIT_CLIENT_DIST` optionally selects an isolated production client
+build for before/after comparisons; it never selects a live instance URL. The audit
uses the existing server `playwright-core`, a fresh context for each cold route,
no browser profile, no dev proxy, and no live-instance URL option. It owns and
closes the fixture and browser, including on SIGINT/SIGTERM. An output filename
@@ -130,6 +132,13 @@ The report records:
base64 binary). These exclude frame/TCP/TLS overhead and are separate from HTTP
bytes; do not add a WebSocket handshake or frame twice. This is CDP accounting,
not a packet capture.
+- Media History loaded at 60, 600 and at least 1,200 records, followed by a
+ responsive resize during scrolling and a return to the top. Each sample records
+ loaded/mounted/visible cards, columns, scroll geometry and CDP DOM nodes after
+ garbage collection. Mounts are bounded by two overscan rows on each side,
+ partial viewport rows and a focused row with keyboard neighbors (at most twelve
+ rows in this fixture), independent of loaded count. Keyboard focus survives
+ scrolling and responsive regrouping. No machine-specific timing gate applies.
- Detail reads after opening a row, then the real Contacts tab click and a full
measured 60-second idle window. Idle bytes/minute use actual elapsed time,
with HTTP encoded/decoded and socket payload bytes separate. Requests count in
diff --git a/scripts/perf/browserCollectionAudit.mjs b/scripts/perf/browserCollectionAudit.mjs
index 3713c26d83..dd7085cfc9 100644
--- a/scripts/perf/browserCollectionAudit.mjs
+++ b/scripts/perf/browserCollectionAudit.mjs
@@ -18,6 +18,62 @@ process.once('SIGINT', stop);
process.once('SIGTERM', stop);
const report = { version: 1, synthetic: true, idleTargetMs: 60000, scenarios: [], failures: [] };
+async function mediaWindow(page, cdp, rows, result) {
+ const samples = result.windowSamples = [];
+ const sample = async label => {
+ const geometry = await page.evaluate(() => {
+ const grid = document.querySelector('[data-media-history-grid]') || document.querySelector('main .grid.gap-3');
+ const wrappers = [...document.querySelectorAll('[data-media-key]')];
+ const cards = wrappers.length ? wrappers : [...document.querySelectorAll('button[aria-label^="synthetic-"]')].map(button => button.parentElement.parentElement);
+ const mounted = cards.length || document.querySelectorAll('button[aria-label^="synthetic-"]').length;
+ let main = grid.parentElement;
+ while (main && !/(auto|scroll)/.test(getComputedStyle(main).overflowY)) main = main.parentElement;
+ return { loaded: Number(grid?.dataset.loadedItems) || mounted, mounted,
+ visible: cards.filter(card => { const r = card.getBoundingClientRect(); const m = main.getBoundingClientRect(); return r.bottom > m.top && r.top < m.bottom; }).length,
+ scrollTop: Math.round(main.scrollTop), scrollHeight: main.scrollHeight,
+ columns: grid ? getComputedStyle(grid).gridTemplateColumns.split(' ').length : 5 };
+ });
+ await cdp.send('HeapProfiler.collectGarbage');
+ const dom = await cdp.send('Memory.getDOMCounters');
+ samples.push({ label, ...geometry, domNodes: dom.nodes });
+ // Two overscan rows each side, partially visible rows, and a pinned focused
+ // row with its keyboard neighbors. The fixture viewport fits at most 3 rows.
+ if (geometry.mounted > geometry.columns * 12 || geometry.visible === 0) throw new Error('Unbounded or blank media window');
+ return geometry;
+ };
+ await rows.first().focus();
+ const focusedLabel = await rows.first().getAttribute('aria-label');
+ await sample('60');
+ for (const target of [600, 1200]) {
+ for (let attempts = 0; attempts < 30; attempts++) {
+ const loaded = await page.evaluate(() => Number(document.querySelector('[data-media-history-grid]')?.dataset.loadedItems)
+ || document.querySelectorAll('button[aria-label^="synthetic-"]').length);
+ if (loaded >= target) break;
+ const response = page.waitForResponse(response => new URL(response.url()).pathname === '/api/image-gen/gallery' && response.status() === 200);
+ await page.getByRole('button', { name: /^Show more/ }).evaluate(button => button.click());
+ await response;
+ await page.waitForFunction(previous => (Number(document.querySelector('[data-media-history-grid]')?.dataset.loadedItems)
+ || document.querySelectorAll('button[aria-label^="synthetic-"]').length) > previous, loaded);
+ }
+ await page.evaluate(() => { let main = document.querySelector('[data-media-history-grid]')?.parentElement || document.querySelector('main .grid.gap-3')?.parentElement; while (main && !/(auto|scroll)/.test(getComputedStyle(main).overflowY)) main = main.parentElement; main.scrollTop = Math.max(0, main.scrollHeight - main.clientHeight * 1.5); });
+ await delay(250);
+ const geometry = await sample(String(target));
+ if (await page.evaluate(() => document.activeElement?.getAttribute('aria-label')) !== focusedLabel) throw new Error('Keyboard focus lost while scrolling');
+ if (geometry.loaded < target) throw new Error('Insufficient extended browsing');
+ }
+ await page.setViewportSize({ width: 640, height: 800 });
+ await delay(250);
+ await sample('resize-mid-scroll');
+ if (await page.evaluate(() => document.activeElement?.getAttribute('aria-label')) !== focusedLabel) throw new Error('Keyboard focus lost while resizing');
+ await page.setViewportSize({ width: 1280, height: 800 });
+ await delay(250);
+ await page.evaluate(() => { let main = document.querySelector('[data-media-history-grid]')?.parentElement || document.querySelector('main .grid.gap-3')?.parentElement; while (main && !/(auto|scroll)/.test(getComputedStyle(main).overflowY)) main = main.parentElement; main.scrollTop = 0; });
+ await delay(250);
+ await sample('return-top');
+ await rows.first().waitFor({ state: 'visible' });
+ return samples;
+}
+
async function scenario(route) {
const context = await browser.newContext({ viewport: { width: 1280, height: 800 }, serviceWorkers: 'block' });
const page = await context.newPage();
@@ -93,6 +149,8 @@ async function scenario(route) {
const dismiss = page.getByRole('button', { name: 'Dismiss and don’t show again', exact: true });
if (await dismiss.isVisible()) await dismiss.click();
if (media) {
+ advance('extended');
+ result.windowSamples = await mediaWindow(page, cdp, rows, result);
advance('detail');
await rows.first().click();
await delay(1000, undefined, { signal: abort.signal });
@@ -143,7 +201,7 @@ async function scenario(route) {
}
try {
- fixture = await startCollectionFixture();
+ fixture = await startCollectionFixture({ clientDist: process.env.COLLECTION_AUDIT_CLIENT_DIST });
report.startup = fixture.startup;
report.cardinalities = fixture.cardinalities;
browser = await chromium.launch({ headless: true, ...(process.env.COLLECTION_AUDIT_BROWSER