Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(activity): virtualize the feed and page on scroll (#6238)
teof0cdeefba5cd
diff --git a/apps/web/src/features/activity/core/feed-rows.test.ts b/apps/web/src/features/activity/core/feed-rows.test.tsnew file mode 100644index 0000000000..9a6c82d2eb--- /dev/null+++ b/apps/web/src/features/activity/core/feed-rows.test.ts@@ -0,0 +1,83 @@+import { describe, expect, it } from 'vitest';+import { decodeActivityEvent } from '../queries/decode';+import { createdEvent, editedEvent } from '../queries/fixtures';+import { flattenFeed, reuseRows, shouldFetchMore } from './feed-rows';++const created = decodeActivityEvent(createdEvent);+const edited = decodeActivityEvent(editedEvent);++describe('flattenFeed', () => {+ it('interleaves day headers and events in order and ends with a tail when more pages exist', () => {+ const rows = flattenFeed(+ [+ { key: 'today', label: 'Today', events: [created] },+ { key: 'yesterday', label: 'Yesterday', events: [edited] },+ ],+ { hasMore: true }+ );+ expect(rows.map((row) => row.kind)).toEqual([+ 'day',+ 'event',+ 'day',+ 'event',+ 'tail',+ ]);+ expect(rows[0]).toEqual({ kind: 'day', key: 'today', label: 'Today' });+ expect(rows[1]).toEqual({ kind: 'event', event: created });+ });++ it('omits the tail on the last page', () => {+ const rows = flattenFeed(+ [{ key: 'today', label: 'Today', events: [created] }],+ { hasMore: false }+ );+ expect(rows.map((row) => row.kind)).toEqual(['day', 'event']);+ });+});++describe('reuseRows', () => {+ it('keeps previous row objects for matching keys and adds the rest', () => {+ const previous = flattenFeed(+ [{ key: 'today', label: 'Today', events: [created] }],+ { hasMore: true }+ );+ const next = flattenFeed(+ [+ { key: 'today', label: 'Today', events: [{ ...created }] },+ { key: 'yesterday', label: 'Yesterday', events: [edited] },+ ],+ { hasMore: false }+ );+ const reused = reuseRows(previous, next);+ expect(reused[0]).toBe(previous[0]);+ expect(reused[1]).toBe(previous[1]);+ expect(reused[2]).toBe(next[2]);+ expect(reused[3]).toBe(next[3]);+ expect(reused.map((row) => row.kind)).toEqual([+ 'day',+ 'event',+ 'day',+ 'event',+ ]);+ });+});++describe('shouldFetchMore', () => {+ it.each([+ // [scrollSize, viewportSize, offset, expected]+ [3000, 800, 0, false],+ [3000, 800, 1399, false],+ [3000, 800, 1400, true],+ [3000, 800, 2200, true],+ [500, 800, 0, true],+ [1000, 50, 800, false],+ [1000, 50, 850, true],+ ])(+ 'scrollSize %i viewport %i offset %i -> %s',+ (scrollSize, viewportSize, offset, expected) => {+ expect(shouldFetchMore({ scrollSize, viewportSize, offset })).toBe(+ expected+ );+ }+ );+});diff --git a/apps/web/src/features/activity/core/feed-rows.ts b/apps/web/src/features/activity/core/feed-rows.tsnew file mode 100644index 0000000000..944b23da21--- /dev/null+++ b/apps/web/src/features/activity/core/feed-rows.ts@@ -0,0 +1,72 @@+import type { ActivityEvent } from './event';+import type { FeedGroup } from './group-events';++/**+ * One virtualized row of the Activity screen. The overview card is row zero+ * so it scrolls with the feed and the virtualizer needs no start margin.+ */+export type FeedRow =+ | { kind: 'overview' }+ | { kind: 'day'; key: string; label: string }+ | { kind: 'event'; event: ActivityEvent }+ | { kind: 'status'; status: 'loading' | 'error' | 'empty' }+ | { kind: 'tail' };++/** Day headers and their events in order, plus a tail row while more pages exist. */+export function flattenFeed(+ groups: FeedGroup[],+ options: { hasMore: boolean }+): FeedRow[] {+ const rows: FeedRow[] = [];+ for (const group of groups) {+ rows.push({ kind: 'day', key: group.key, label: group.label });+ for (const event of group.events) rows.push({ kind: 'event', event });+ }+ if (options.hasMore) rows.push({ kind: 'tail' });+ return rows;+}++function rowKey(row: FeedRow): string {+ switch (row.kind) {+ case 'overview':+ case 'tail':+ return row.kind;+ case 'day':+ return `day:${row.key}`;+ case 'event':+ return `event:${row.event.id}`;+ case 'status':+ return `status:${row.status}`;+ }+}++/**+ * Carry previous row objects forward where the key matches, so the list+ * keys rows by reference and a refetch or a paging flag flip does not+ * remount every mounted row. Events are immutable once recorded, so a+ * matching id is a matching row.+ */+export function reuseRows(previous: FeedRow[], next: FeedRow[]): FeedRow[] {+ if (previous.length === 0) return next;+ const byKey = new Map(previous.map((row) => [rowKey(row), row]));+ return next.map((row) => byKey.get(rowKey(row)) ?? row);+}++/** Floor for the near-bottom threshold so tiny viewports still page. */+const MIN_FETCH_THRESHOLD = 100;++/**+ * Whether the scroller is within one viewport of its end, the point at which+ * the next page should start loading so it usually lands before the user+ * reaches the bottom.+ */+export function shouldFetchMore(metrics: {+ scrollSize: number;+ viewportSize: number;+ offset: number;+}): boolean {+ const threshold = Math.max(MIN_FETCH_THRESHOLD, metrics.viewportSize);+ return (+ metrics.scrollSize - metrics.viewportSize - metrics.offset <= threshold+ );+}diff --git a/apps/web/src/features/activity/primitives/my-activity.test.ts b/apps/web/src/features/activity/primitives/my-activity.test.tsindex 48f42adc14..2942cca3b8 100644--- a/apps/web/src/features/activity/primitives/my-activity.test.ts+++ b/apps/web/src/features/activity/primitives/my-activity.test.ts@@ -10,6 +10,8 @@ afterEach(() => {for (const dispose of disposals.splice(0)) dispose();});+const settle = () => new Promise<void>((resolve) => setTimeout(resolve, 0));+function setup() {const context = createMockActivityContext();let state!: MyActivityState;@@ -72,6 +74,89 @@ describe('createMyActivityState', () => {expect(feed.hasMore).toBe(false);});+ it('exposes the overview as row zero and the flattened feed after it', () => {+ const { state, graphql } = setup();+ expect(state.rows().map((row) => row.kind)).toEqual(['overview', 'status']);++ graphql.latest('MyActivity').resolve(feedPage([createdEvent], 'c2'));+ const ready = state.rows();+ expect(ready.map((row) => row.kind)).toEqual([+ 'overview',+ 'day',+ 'event',+ 'tail',+ ]);++ state.loadMore();+ // The in-flight flag flips but the mounted rows keep their identity.+ expect(state.rows()[1]).toBe(ready[1]);+ expect(state.rows()[2]).toBe(ready[2]);++ graphql.latest('MyActivity').resolve(feedPage([editedEvent], null));+ expect(state.rows().map((row) => row.kind)).toEqual([+ 'overview',+ 'day',+ 'event',+ 'event',+ ]);+ expect(state.rows()[2]).toBe(ready[2]);+ });++ it('ignores loadMore while a page is in flight or none remain', () => {+ const { state, graphql } = setup();+ graphql.latest('MyActivity').resolve(feedPage([createdEvent], 'c2'));+ const requests = () =>+ graphql.pending.filter((op) => op.name === 'MyActivity').length;++ state.loadMore();+ state.loadMore();+ expect(requests()).toBe(2);++ graphql.latest('MyActivity').resolve(feedPage([editedEvent], null));+ state.loadMore();+ expect(requests()).toBe(2);+ });++ it('stops auto-paging after a failed page until retryMore', async () => {+ const { state, graphql } = setup();+ graphql.latest('MyActivity').resolve(feedPage([createdEvent], 'c2'));+ const requests = () =>+ graphql.pending.filter((op) => op.name === 'MyActivity').length;++ state.loadMore();+ expect(requests()).toBe(2);+ graphql.latest('MyActivity').fail('boom');+ // The page observer settles its failure a few microtasks after the result.+ await settle();++ const feed = state.feed();+ expect(feed.t).toBe('ready');+ if (feed.t !== 'ready') return;+ expect(feed.moreFailed).toBe(true);+ expect(feed.loadingMore).toBe(false);+ expect(feed.hasMore).toBe(true);++ // The near-end check keeps firing while the user rests at the bottom;+ // none of those turn into another request.+ state.loadMore();+ state.loadMore();+ expect(requests()).toBe(2);++ state.retryMore();+ await settle();+ expect(requests()).toBe(3);+ expect(graphql.latest('MyActivity').variables).toEqual({+ input: { limit: 50, cursor: 'c2' },+ });++ graphql.latest('MyActivity').resolve(feedPage([editedEvent], null));+ const after = state.feed();+ if (after.t !== 'ready') throw new Error('feed should stay ready');+ expect(after.moreFailed).toBe(false);+ expect(after.hasMore).toBe(false);+ expect(after.groups.flatMap((g) => g.events)).toHaveLength(2);+ });+it('is empty when the first page has no rows', () => {const { state, graphql } = setup();graphql.latest('MyActivity').resolve(feedPage([]));diff --git a/apps/web/src/features/activity/primitives/my-activity.ts b/apps/web/src/features/activity/primitives/my-activity.tsindex bd8819e6d4..3527ddd3a4 100644--- a/apps/web/src/features/activity/primitives/my-activity.ts+++ b/apps/web/src/features/activity/primitives/my-activity.ts@@ -1,6 +1,7 @@import { type Accessor, createMemo } from 'solid-js';import type { ActivityContext } from '../context/activity-context';import type { ActivityOverview } from '../core/event';+import { type FeedRow, flattenFeed, reuseRows } from '../core/feed-rows';import { type FeedGroup, groupEventsByDay } from '../core/group-events';import { createMyActivityQuery } from '../queries/feed-query';import { createMyActivityOverviewQuery } from '../queries/overview-query';@@ -9,7 +10,14 @@ export type FeedView =| { t: 'loading' }| { t: 'error' }| { t: 'empty' }- | { t: 'ready'; groups: FeedGroup[]; hasMore: boolean; loadingMore: boolean };+ | {+ t: 'ready';+ groups: FeedGroup[];+ hasMore: boolean;+ loadingMore: boolean;+ /** The last next-page request failed; auto-paging waits for `retryMore`. */+ moreFailed: boolean;+ };export type OverviewView =| { t: 'loading' }@@ -19,7 +27,16 @@ export type OverviewView =export type MyActivityState = {overview: Accessor<OverviewView>;feed: Accessor<FeedView>;+ /** Every virtualized row of the screen: the overview first, then the feed. */+ rows: Accessor<FeedRow[]>;+ /**+ * Fetch the next feed page. No-op while one is in flight, none remain, or+ * the last attempt failed (so a scroller resting near the end does not+ * hammer a failing endpoint).+ */loadMore: () => void;+ /** Retry the failed next page. The one way to page again after a failure. */+ retryMore: () => void;};/**@@ -50,6 +67,7 @@ export function createMyActivityState(groups: groups(),hasMore: feedQuery.hasNextPage,loadingMore: feedQuery.isFetchingNextPage,+ moreFailed: feedQuery.isFetchNextPageError,};}if (feedQuery.isLoading) return { t: 'loading' };@@ -57,9 +75,28 @@ export function createMyActivityState(return { t: 'empty' };});+ const rows = createMemo<FeedRow[]>((previous) => {+ const current = feed();+ const feedRows: FeedRow[] =+ current.t === 'ready'+ ? flattenFeed(current.groups, { hasMore: current.hasMore })+ : [{ kind: 'status', status: current.t }];+ return reuseRows(previous, [{ kind: 'overview' }, ...feedRows]);+ }, []);++ const fetchNext = () => {+ if (!feedQuery.hasNextPage || feedQuery.isFetchingNextPage) return;+ void feedQuery.fetchNextPage();+ };+return {overview,feed,- loadMore: () => void feedQuery.fetchNextPage(),+ rows,+ loadMore: () => {+ if (feedQuery.isFetchNextPageError) return;+ fetchNext();+ },+ retryMore: fetchNext,};}diff --git a/apps/web/src/features/activity/views/my-activity-view.test.tsx b/apps/web/src/features/activity/views/my-activity-view.test.tsxindex 2deef70563..8a7438827b 100644--- a/apps/web/src/features/activity/views/my-activity-view.test.tsx+++ b/apps/web/src/features/activity/views/my-activity-view.test.tsx@@ -1,4 +1,5 @@import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';+import type { JSX } from 'solid-js';import { afterEach, describe, expect, it, vi } from 'vitest';import { ActivityContextProvider } from '../context/activity-context';import { placeholderOverview } from '../core/placeholder-overview';@@ -11,6 +12,29 @@ vi.mock('@components/app/split-layout/components/SplitHeader', () => ({SplitHeaderLeft: (props: { children: unknown }) => props.children,}));+// jsdom has no layout, so the virtualizer renders every row and exposes a+// fake handle plus its scroll callback so tests can drive paging.+const virtual = vi.hoisted(() => ({+ onScroll: undefined as ((offset: number) => void) | undefined,+ handle: { scrollSize: 3000, viewportSize: 800, scrollOffset: 0 },+}));++vi.mock('virtua/solid', async () => {+ const { For } = await import('solid-js');+ return {+ Virtualizer: (props: {+ data: readonly unknown[];+ children: (row: unknown, index: () => number) => JSX.Element;+ ref?: (handle: unknown) => void;+ onScroll?: (offset: number) => void;+ }) => {+ props.ref?.(virtual.handle);+ virtual.onScroll = props.onScroll;+ return <For each={props.data}>{(row, i) => props.children(row, i)}</For>;+ },+ };+});+vi.mock('@core/component/LexicalMarkdown/component/core/StaticMarkdown',() => ({@@ -36,6 +60,8 @@ vi.mock('@service-storage/websocket', () => ({afterEach(cleanup);+const settle = () => new Promise<void>((resolve) => setTimeout(resolve, 0));+function renderView() {const context = createMockActivityContext();const onOpen = vi.fn();@@ -85,8 +111,8 @@ describe('MyActivityView', () => {);});- it('renders grouped rows with actor names and pages on Show more', async () => {- const { graphql } = renderView();+ it('renders grouped rows with actor names and pages when scrolled near the end', () => {+ const { container, graphql } = renderView();graphql.latest('MyActivity').resolve(feedPage([createdEvent, messagedEvent], 'cursor-2'));@@ -95,16 +121,75 @@ describe('MyActivityView', () => {expect(rows()[0]?.getAttribute('data-activity-action')).toBe('created');expect(rows()[1]?.getAttribute('data-activity-action')).toBe('messaged');expect(screen.getAllByText('sarah')).toHaveLength(2);+ expect(screen.queryByRole('button', { name: 'Show more' })).toBeNull();+ expect(container.querySelector('[data-activity-feed-tail]')).not.toBeNull();++ const scroll = virtual.onScroll;+ if (!scroll) throw new Error('virtualizer did not register onScroll');+ const feedRequests = () =>+ graphql.pending.filter((op) => op.name === 'MyActivity').length;+ expect(feedRequests()).toBe(1);- fireEvent.click(screen.getByRole('button', { name: 'Show more' }));+ // Far from the end: 3000 - 800 - 0 > max(100, 800).+ scroll(0);+ expect(feedRequests()).toBe(1);++ // Within one viewport of the end.+ scroll(1500);+ expect(feedRequests()).toBe(2);const next = graphql.latest('MyActivity');expect(next.variables).toEqual({input: { limit: 50, cursor: 'cursor-2' },});+ expect(container.textContent).toContain('Loading…');++ // A second scroll while the page is in flight does not double-fetch.+ scroll(1600);+ expect(feedRequests()).toBe(2);next.resolve(feedPage([{ ...createdEvent, id: 'evt-99' }], null));expect(rows()).toHaveLength(3);- expect(screen.queryByRole('button', { name: 'Show more' })).toBeNull();+ expect(container.querySelector('[data-activity-feed-tail]')).toBeNull();++ // No more pages: scrolling to the end fetches nothing.+ scroll(2200);+ expect(feedRequests()).toBe(2);+ });++ it('offers a retry instead of re-paging when the next page fails', async () => {+ const { container, graphql } = renderView();+ graphql+ .latest('MyActivity')+ .resolve(feedPage([createdEvent, messagedEvent], 'cursor-2'));+ const scroll = virtual.onScroll;+ if (!scroll) throw new Error('virtualizer did not register onScroll');+ const feedRequests = () =>+ graphql.pending.filter((op) => op.name === 'MyActivity').length;++ scroll(1500);+ expect(feedRequests()).toBe(2);+ graphql.latest('MyActivity').fail('boom');+ await settle();++ const tail = container.querySelector('[data-activity-feed-tail]');+ expect(tail?.textContent).toContain("Couldn't load more.");+ expect(tail?.textContent).not.toContain('Loading…');++ // Still resting near the end: no automatic re-fetch.+ scroll(1500);+ scroll(1600);+ expect(feedRequests()).toBe(2);++ fireEvent.click(screen.getByRole('button', { name: 'Retry' }));+ await settle();+ expect(feedRequests()).toBe(3);+ expect(container.textContent).toContain('Loading…');++ graphql+ .latest('MyActivity')+ .resolve(feedPage([{ ...createdEvent, id: 'evt-99' }], null));+ expect(rows()).toHaveLength(3);+ expect(container.querySelector('[data-activity-feed-tail]')).toBeNull();});it('asks the host to open the row entity', () => {diff --git a/apps/web/src/features/activity/views/my-activity-view.tsx b/apps/web/src/features/activity/views/my-activity-view.tsxindex 0bff1a0dab..e3a181e5c4 100644--- a/apps/web/src/features/activity/views/my-activity-view.tsx+++ b/apps/web/src/features/activity/views/my-activity-view.tsx@@ -1,21 +1,39 @@import { SoupSectionHeader } from '@app/features/next-soup/soup-view/section-header';import { SplitHeaderLeft } from '@components/app/split-layout/components/SplitHeader';import { StaticMarkdownContext } from '@core/component/LexicalMarkdown/component/core/StaticMarkdown';-import { Button } from '@ui';-import { For, type JSX, Match, Show, Switch } from 'solid-js';+import {+ createEffect,+ createSignal,+ For,+ type JSX,+ on,+ onCleanup,+ Show,+ Suspense,+} from 'solid-js';+import { match } from 'ts-pattern';+import { Virtualizer, type VirtualizerHandle } from 'virtua/solid';import { ActionGraph } from '../components/action-graph';+import { ActivityTimelineRow as ActivityTimelineRowView } from '../components/activity-timeline-row';import { TopEntitiesSection, TopEntityChip } from '../components/top-entities';import {type OpenEntityTarget,useActivityContext,} from '../context/activity-context';import type { ActivityEvent, ActivityTopEntity } from '../core/event';+import { type FeedRow, shouldFetchMore } from '../core/feed-rows';import { placeholderOverview } from '../core/placeholder-overview';import { createActorName } from '../primitives/actor-name';import { createEntityOpener } from '../primitives/entity-opener';-import { createMyActivityState } from '../primitives/my-activity';+import {+ createMyActivityState,+ type MyActivityState,+} from '../primitives/my-activity';import { ActivityTimelineRow } from './activity-timeline-row';+/** Pixels of rows virtua keeps mounted beyond the viewport on each side. */+const FEED_BUFFER_PX = 400;+function OverviewInset(props: { children: JSX.Element }) {return (<div class="mx-1 flex w-[calc(100%-0.5rem)] min-w-0 flex-col gap-2 pb-2">@@ -33,114 +51,63 @@ function FeedStatus(props: { children: JSX.Element }) {}/**- * The user's own activity, newest first. Reads `ActivityContext`;- * the host decides what a row click opens.+ * The user's own activity, newest first, as one virtualized list with the+ * overview card as its first row. Scrolling near the end fetches the next+ * page. Reads `ActivityContext`; the host decides what a row click opens.*/export function MyActivityView(props: {onOpen: (target: OpenEntityTarget) => void;}) {const context = useActivityContext();const state = createMyActivityState(context);- const overview = () => {- const current = state.overview();- return current.t === 'ready' ? current.overview : undefined;- };- const feed = () => {- const current = state.feed();- return current.t === 'ready' ? current : undefined;+ const [scroller, setScroller] = createSignal<HTMLDivElement>();+ let handle: VirtualizerHandle | undefined;++ const fetchMoreIfNearEnd = (offset: number) => {+ if (!handle) return;+ if (+ shouldFetchMore({+ scrollSize: handle.scrollSize,+ viewportSize: handle.viewportSize,+ offset,+ })+ ) {+ state.loadMore();+ }};+ // A page that does not fill the viewport never scrolls, so re-check once+ // virtua has laid out the new rows.+ createEffect(+ on(state.rows, () => {+ const frame = requestAnimationFrame(() =>+ fetchMoreIfNearEnd(handle?.scrollOffset ?? 0)+ );+ onCleanup(() => cancelAnimationFrame(frame));+ })+ );+return (<div class="@container/u-list flex size-full flex-col"><SplitHeaderLeft><span class="font-semibold text-sm">Activity</span></SplitHeaderLeft><StaticMarkdownContext>- <div class="min-h-0 flex-1 overflow-y-auto py-1">+ <div ref={setScroller} class="min-h-0 flex-1 overflow-y-auto py-1"><div class="mx-auto w-full max-w-[1000px]">- <Show- when={overview()}- fallback={- <OverviewInset>- <Show- when={state.overview().t === 'error'}- fallback={- <ActionGraph- overview={placeholderOverview(new Date())}- skeleton- />- }- >- <p class="px-2 py-1 text-ink-extra-muted text-xs">- Activity overview is unavailable right now.- </p>- </Show>- </OverviewInset>- }+ <Virtualizer+ data={state.rows()}+ scrollRef={scroller()}+ ref={(next) => {+ handle = next;+ }}+ bufferSize={FEED_BUFFER_PX}+ onScroll={fetchMoreIfNearEnd}>- {(overview) => (- <OverviewInset>- <ActionGraph overview={overview()} />- <Show when={overview().topEntities.length > 0}>- <TopEntitiesSection>- <For each={overview().topEntities}>- {(entity) => (- <OpenableTopEntityChip- entity={entity}- onOpen={props.onOpen}- />- )}- </For>- </TopEntitiesSection>- </Show>- </OverviewInset>+ {(row) => (+ <FeedRowView row={row} state={state} onOpen={props.onOpen} />)}- </Show>- <Switch>- <Match when={feed()}>- {(feed) => (- <>- <For each={feed().groups}>- {(group) => (- <>- <SoupSectionHeader>{group.label}</SoupSectionHeader>- <For each={group.events}>- {(event) => (- <NamedActivityRow- event={event}- onOpen={props.onOpen}- />- )}- </For>- </>- )}- </For>- <Show when={feed().hasMore}>- <div class="flex justify-center py-2">- <Button- variant="ghost"- onClick={state.loadMore}- disabled={feed().loadingMore}- >- {feed().loadingMore ? 'Loading…' : 'Show more'}- </Button>- </div>- </Show>- </>- )}- </Match>- <Match when={state.feed().t === 'loading'}>- <FeedStatus>Loading…</FeedStatus>- </Match>- <Match when={state.feed().t === 'error'}>- <FeedStatus>- Activity is unavailable right now. Try again in a moment.- </FeedStatus>- </Match>- <Match when={state.feed().t === 'empty'}>- <FeedStatus>No activity yet.</FeedStatus>- </Match>- </Switch>+ </Virtualizer></div></div></StaticMarkdownContext>@@ -148,6 +115,116 @@ export function MyActivityView(props: {);}+function FeedRowView(props: {+ row: FeedRow;+ state: MyActivityState;+ onOpen: (target: OpenEntityTarget) => void;+}) {+ return match(props.row)+ .with({ kind: 'overview' }, () => (+ <OverviewRow state={props.state} onOpen={props.onOpen} />+ ))+ .with({ kind: 'day' }, (row) => (+ <SoupSectionHeader>{row.label}</SoupSectionHeader>+ ))+ .with({ kind: 'event' }, (row) => (+ <NamedActivityRow event={row.event} onOpen={props.onOpen} />+ ))+ .with({ kind: 'status', status: 'loading' }, () => (+ <FeedStatus>Loading…</FeedStatus>+ ))+ .with({ kind: 'status', status: 'error' }, () => (+ <FeedStatus>+ Activity is unavailable right now. Try again in a moment.+ </FeedStatus>+ ))+ .with({ kind: 'status', status: 'empty' }, () => (+ <FeedStatus>No activity yet.</FeedStatus>+ ))+ .with({ kind: 'tail' }, () => <FeedTail state={props.state} />)+ .exhaustive();+}++function FeedTail(props: { state: MyActivityState }) {+ const ready = () => {+ const feed = props.state.feed();+ return feed.t === 'ready' ? feed : undefined;+ };+ return (+ <div+ class="flex h-10 items-center justify-center gap-2 text-ink-muted text-sm"+ aria-live="polite"+ data-activity-feed-tail+ >+ <Show when={ready()?.loadingMore}>Loading…</Show>+ <Show when={!ready()?.loadingMore && ready()?.moreFailed}>+ <span>Couldn't load more.</span>+ <button+ type="button"+ class="text-ink underline-offset-2 hover:underline"+ onClick={() => props.state.retryMore()}+ >+ Retry+ </button>+ </Show>+ </div>+ );+}++function OverviewRow(props: {+ state: MyActivityState;+ onOpen: (target: OpenEntityTarget) => void;+}) {+ const overview = () => {+ const current = props.state.overview();+ return current.t === 'ready' ? current.overview : undefined;+ };+ return (+ <Show+ when={overview()}+ fallback={+ <OverviewInset>+ <Show+ when={props.state.overview().t === 'error'}+ fallback={+ <ActionGraph+ overview={placeholderOverview(new Date())}+ skeleton+ />+ }+ >+ <p class="px-2 py-1 text-ink-extra-muted text-xs">+ Activity overview is unavailable right now.+ </p>+ </Show>+ </OverviewInset>+ }+ >+ {(overview) => (+ <OverviewInset>+ <ActionGraph overview={overview()} />+ <Show when={overview().topEntities.length > 0}>+ <TopEntitiesSection>+ <For each={overview().topEntities}>+ {(entity) => (+ <OpenableTopEntityChip+ entity={entity}+ onOpen={props.onOpen}+ />+ )}+ </For>+ </TopEntitiesSection>+ </Show>+ </OverviewInset>+ )}+ </Show>+ );+}++// Rows mount as the user scrolls, and a row whose entity preview is still a+// cold query suspends the nearest boundary. Each row carries its own so the+// pane boundary never re-inserts the scroller, which would reset its scroll+// position to the top.function NamedActivityRow(props: {event: ActivityEvent;onOpen: (target: OpenEntityTarget) => void;@@ -155,17 +232,34 @@ function NamedActivityRow(props: {const context = useActivityContext();const name = createActorName(context, () => props.event.actorId);return (- <ActivityTimelineRow- event={props.event}- actorName={name()}- onOpen={props.onOpen}- />+ <Suspense+ fallback={+ <ActivityTimelineRowView event={props.event} actorName={name()} />+ }+ >+ <ActivityTimelineRow+ event={props.event}+ actorName={name()}+ onOpen={props.onOpen}+ />+ </Suspense>);}function OpenableTopEntityChip(props: {entity: ActivityTopEntity;onOpen: (target: OpenEntityTarget) => void;+}) {+ return (+ <Suspense fallback={<TopEntityChip entity={props.entity} />}>+ <ResolvedTopEntityChip entity={props.entity} onOpen={props.onOpen} />+ </Suspense>+ );+}++function ResolvedTopEntityChip(props: {+ entity: ActivityTopEntity;+ onOpen: (target: OpenEntityTarget) => void;}) {const context = useActivityContext();const opener = createEntityOpener(diff --git a/docs/AGENT_GUIDE/surfaces.md b/docs/AGENT_GUIDE/surfaces.mdindex a3da593263..ff8647056b 100644--- a/docs/AGENT_GUIDE/surfaces.md+++ b/docs/AGENT_GUIDE/surfaces.md@@ -119,7 +119,11 @@ GitHub-style actions heatmap (one a11y node per day — makes snapshots huge; prsnapshot to a file), then a `Most active` section header (styled like the feed's day headers)over a wrapping row of pill chips (entity icon, name, action count; click opens the entity,shift-click opens a new split; the section is absent when there are no entities), then a feed-of "You edited/created X" entries.+of "You edited/created X" entries grouped under day headers. The whole page is one virtualized+list: only rows near the viewport are in the DOM, and scrolling near the bottom fetches the+next page automatically (a `Loading…` tail appears while it lands). If a page fails, the tail+reads `Couldn't load more.` with a `Retry` button and automatic paging stops until it is+pressed. There is no `Show more` button.## Home — `/app/component/home`