@remit/web-client 0.0.279 → 0.0.280

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.279",
+  "version": "0.0.280",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/DailyBrief.tsx

@@ -25,9 +25,12 @@
  * over the rows. `FilterPanelProvider` shares that panel's open state between
  * the caret and the sheet, the same shape `MailViewChrome` gives the mailbox and
  * Starred views. The list draws those controls but applies none of them: the
- * category and every chip a parameter can express travel with the section
- * requests, and the two that cannot ("From contacts", "Today") are applied here
- * alongside the residual tokens (#314). The phone search takeover reads the same
+ * category, the account pill and every chip a parameter can express travel with
+ * the section requests, and the two that cannot ("From contacts", "Today") are
+ * applied here alongside the residual tokens (#314). The account pill is a
+ * parameter rather than a pass over the rows because a count taken over every
+ * account is not the size of a list showing one, which is what used to take the
+ * number off every header (#1136). The phone search takeover reads the same
  * selection and the same rows, so a filter set on one surface holds on the
  * other. Under a query the chips are terms of that query — see
  * `briefChipFilters` — so what narrows the list is readable and editable in the
@@ -112,8 +115,6 @@ import {
 	BRIEF_CATEGORIES,
 	type BriefCategoryResult,
 	briefSections,
-	briefSectionTotal,
-	excludeMutedSenders,
 	matchesSearchTokens,
 	toThreadRowData,
 } from "@/lib/brief";
@@ -606,8 +607,14 @@ export function DailyBrief({
 	// chip decides which sections are on screen rather than narrowing a shared
 	// one.
 	const { criteria: chipCriteria, residual: residualTokens } = useMemo(
-		() => briefCriteria(requestCategory, requestFilters, queryTokens),
-		[requestCategory, requestFilters, queryTokens],
+		() =>
+			briefCriteria(
+				requestCategory,
+				requestFilters,
+				queryTokens,
+				selectedAccountId === "all" ? undefined : selectedAccountId,
+			),
+		[requestCategory, requestFilters, queryTokens, selectedAccountId],
 	);
 	const shownCategories = useMemo<RemitImapMessageCategory[]>(
 		() =>
@@ -624,13 +631,13 @@ export function DailyBrief({
 		}),
 		[chipCriteria, sq, requestCategory],
 	);
-	// The account pills and the tokens no parameter carries narrow the rows after
-	// they arrive, so while either is active the count is of a wider set than the
-	// list and the sections show no number at all.
+	// The tokens no parameter carries narrow the rows after they arrive, so while
+	// one is active the count is of a wider set than the list and the sections
+	// show no number at all. The account pills are no longer among them: the
+	// request carries the account, so the count narrows with the list (#1136).
 	const counted = briefCountsMatchRows({
 		residual: residualTokens,
 		attributes: requestFilters,
-		accountScoped: selectedAccountId !== "all",
 	});
 
 	const {
@@ -666,12 +673,12 @@ export function DailyBrief({
 		refetchSections();
 	}, [underQuery, refetchSearch, refetchSections]);
 
-	// What the request could not carry: muted senders, the account pill, the two
-	// chips no endpoint takes a parameter for ("From contacts", "Today"), and the
-	// residual tokens (`from:`, `subject:`, `before:`, `after:`, `in:`,
-	// `account:`) that `listAllThreads` has no parameter for. Everything else was
-	// answered over the whole scope by the request itself, and the order the rows
-	// arrived in is kept — narrowing never re-sorts.
+	// What the request could not carry: the two chips no endpoint takes a
+	// parameter for ("From contacts", "Today"), and the residual tokens
+	// (`before:`, `after:`, `in:`, `account:`). Everything else — the account
+	// pill, mute, the free text, `from:` and `subject:` — was answered over the
+	// whole scope by the request itself, and the order the rows arrived in is
+	// kept: narrowing never re-sorts.
 	const clientOnlyFilters = useMemo(
 		() => briefClientOnlyFilters(requestFilters),
 		[requestFilters],
@@ -682,23 +689,21 @@ export function DailyBrief({
 			// `count` is thread-distinct, and a list keying on messageId puts twelve
 			// rows under a header reading one. Collapsed before anything reads a
 			// length, so the rows and the number are the same unit.
-			dedupeByThread(excludeMutedSenders(rows))
+			dedupeByThread(rows)
 				.map(toThreadRowData)
 				.filter(
 					(t) =>
-						(selectedAccountId === "all" ||
-							t.accountId === selectedAccountId) &&
 						matchesBriefFilters(t, clientOnlyFilters) &&
 						matchesSearchTokens(t, residualTokens),
 				),
-		[selectedAccountId, clientOnlyFilters, residualTokens],
+		[clientOnlyFilters, residualTokens],
 	);
 
 	const briefRows = useMemo<BriefCategoryResult[]>(
 		() =>
 			sectionRows.map((section) => ({
 				category: section.category,
-				total: briefSectionTotal(section.total, section.rows),
+				total: section.total,
 				atCap: section.atCap,
 				loading: section.loading,
 				failed: section.failed,

package/src/components/mail/FlaggedList.tsx

@@ -18,6 +18,13 @@
  * pages the user happened to have loaded, so a category whose mail sat below
  * the newest page showed an empty list, and the count grew with every press of
  * "load more" while being presented as a total.
+ *
+ * The free text and the `from:` / `subject:` tokens are parameters too (#1128,
+ * #1135), so a search is one listing request rather than a second query merged
+ * into it. That is what keeps a search's failure loud, its pages continuable
+ * and its loading state its own — a separate search query had none of the
+ * three, so an expired session read as "no matches", "Load more" did nothing,
+ * and a cached listing flashed the empty state.
  */
 import {
 	flaggedFilterConfig,
@@ -32,17 +39,11 @@ import { formatErrorMessage } from "@/components/ui/ErrorState";
 import { useIsDesktop } from "@/hooks/useMediaQuery";
 import { useSearchTokenContext } from "@/hooks/useSearchTokenContext";
 import {
-	useStarredTextSearch,
 	useStarredThreads,
 	useStarredUnreadCount,
 } from "@/hooks/useStarredThreads";
 import type { TriageContextUpdate } from "@/hooks/useTriageLayer";
-import {
-	matchesBriefSearch,
-	matchesSearchTokens,
-	mergeSearchRows,
-	toThreadRowData,
-} from "@/lib/brief";
+import { matchesSearchTokens, toThreadRowData } from "@/lib/brief";
 import { buildBugReportContext, buildGitHubIssueUrl } from "@/lib/bug-report";
 import { flaggedCriteria } from "@/lib/flagged-criteria";
 import { useListHeaderChrome } from "@/lib/list-header-chrome";
@@ -65,9 +66,6 @@ import {
 	useThreadListSelection,
 } from "./ThreadListInteraction";
 
-/** One page of the server-filtered text search, merged with the listing below. */
-const TEXT_SEARCH_PAGE_SIZE = 200;
-
 /**
  * The wizard this view's verbs walk, and the one its search entry lands on.
  *
@@ -185,6 +183,10 @@ export function FlaggedList({
 		[criteria, sq],
 	);
 
+	// One request, free text included. The text is a parameter like every other
+	// criterion, so a search is this listing narrowed rather than a second query
+	// beside it — which is what gives a search the same error state, the same
+	// pagination and the same loading state as the unsearched list.
 	const {
 		threads,
 		isLoading,
@@ -194,27 +196,17 @@ export function FlaggedList({
 		fetchNextPage,
 		hasNextPage,
 		isFetchingNextPage,
-	} = useStarredThreads(criteria);
-	const textMatches = useStarredTextSearch(textCriteria, TEXT_SEARCH_PAGE_SIZE);
+	} = useStarredThreads(textCriteria);
 
-	const rows = useMemo<ThreadRowData[]>(() => {
-		const listed = dedupeByThread(threads).map(toThreadRowData);
-		// No free text: the server-filtered listing as it comes.
-		const matched = sq
-			? mergeSearchRows(
-					// The snippet half, over the rows already loaded. It only ever adds
-					// to the server's set — it is never what decides membership.
-					listed.filter((t) => matchesBriefSearch(t, sq)),
-					dedupeByThread(textMatches).map(toThreadRowData),
-				)
-			: listed;
-		// What is left is what no parameter can carry: `before:`, `after:`, `in:`,
-		// `account:`, and a token the chips overruled. The collapse runs last so
-		// the two halves of a text search cannot land one conversation twice.
-		return dedupeByThread(matched).filter((t) =>
-			matchesSearchTokens(t, residualTokens),
-		);
-	}, [threads, textMatches, sq, residualTokens]);
+	const rows = useMemo<ThreadRowData[]>(
+		() =>
+			// What is left is what no parameter can carry: `before:`, `after:`,
+			// `in:`, `account:`, and a token the chips overruled.
+			dedupeByThread(threads)
+				.map(toThreadRowData)
+				.filter((t) => matchesSearchTokens(t, residualTokens)),
+		[threads, residualTokens],
+	);
 
 	const openRow = useCallback(
 		(id: string, options?: OpenMessageOptions) => {
@@ -250,9 +242,9 @@ export function FlaggedList({
 	const unreadCount = useStarredUnreadCount(textCriteria) ?? null;
 
 	// An empty list has to say how much was looked at, and the answer comes off
-	// the request. Every chip and every carried token is a column on the row, so
-	// the server answered over the whole collection; a residual token, or the
-	// snippet half of a free-text search, only ever saw the pages loaded so far.
+	// the request. Every chip, the free text and every carried token is a field
+	// on the row, so the server answered each over the whole collection; only a
+	// residual token — a date, a mailbox, an account — saw the loaded pages.
 	//
 	// `is:starred` is dropped: this view is starred mail, so the token restates
 	// the collection rather than narrowing it.
@@ -263,7 +255,7 @@ export function FlaggedList({
 	const listFilter: MessageListFilter | undefined = listNarrowing({
 		chips: { category: selectedCategory, attributes: activeFilters },
 		tokens: narrowingTokens,
-		reach: residualTokens.length > 0 || sq ? "loaded-pages" : "whole-folder",
+		reach: residualTokens.length > 0 ? "loaded-pages" : "whole-folder",
 		onClear: clearNarrowing,
 	});
 

package/src/components/mail/brief-server-sections.render.test.ts

@@ -546,33 +546,38 @@ describe("the brief's sections come from the server (#312)", () => {
 		);
 	});
 
-	// A total is withheld whenever something narrows the rows after they arrive —
-	// here a muted sender. The number goes; the way out of the section must not,
-	// or the rest of the category is unreachable.
-	it("keeps the way to the whole category when the total is withheld", async () => {
-		const dom = await mountWith((call) => {
-			const params = new URL(call.url, "http://localhost").searchParams;
-			if (params.get("count") === "true") return undefined;
-			if (!params.getAll("category").includes("marketing")) return undefined;
-			const page = (ROWS.marketing ?? []).slice(0, SECTION_ROW_CAP);
-			return {
-				items: page.map((row, index) =>
-					index === 0 ? { ...row, muted: true } : row,
-				),
-			};
-		});
-		await settled(dom, renderedSubjects("marketing", SECTION_ROW_CAP)[1]);
+	// #1137: mute used to be applied after the rows arrived, so a header counted
+	// mail the list dropped and "Show all" opened rows the brief would not
+	// render. The brief asks the server to leave muted senders out instead, of
+	// the rows and of the count alike.
+	it("asks every section and every count to leave muted senders out", async () => {
+		const mounted = await mount();
+		await settled(mounted, renderedSubjects("marketing", SECTION_ROW_CAP)[0]);
 
-		const marketing = dom.byText("button", "Marketing");
-		assert.doesNotMatch(
+		const asked = threadRequests();
+		assert.ok(asked.length > 0, "the brief issued no request");
+		for (const call of asked) {
+			assert.equal(
+				paramsOf(call).get("muted"),
+				"false",
+				"a brief request counted or listed muted senders",
+			);
+		}
+	});
+
+	// The number is the server's, and it now answers the same predicate the list
+	// does, so it is stated rather than withheld.
+	it("states the section's size with mute already taken off it", async () => {
+		const mounted = await mount();
+		await settled(mounted, renderedSubjects("marketing", SECTION_ROW_CAP)[0]);
+
+		const marketing = mounted.byText("button", "Marketing");
+		assert.match(
 			marketing.textContent ?? "",
 			new RegExp(String(countOf("marketing"))),
-			"a count taken with a muted sender in it was stated as the section's size",
-		);
-		assert.ok(
-			dom.text().includes("Show all"),
-			"withholding the number stranded the reader in the section",
+			"the section withheld a number the request had narrowed",
 		);
+		assert.ok(mounted.text().includes("Show all"));
 	});
 
 	// The requests are built from committed state. Typing is not committing: a

package/src/components/mail/flagged-search-reach.render.test.ts

@@ -0,0 +1,272 @@
+/**
+ * A search of the Starred collection is the listing narrowed, not a second
+ * query beside it.
+ *
+ * It used to be a second query: one uncontinuable page, with no error state and
+ * no loading state of its own. Three things followed, and none of them is
+ * visible from a unit test of the criteria — only from the screen.
+ *
+ * A failed search rendered as "no matches". The generated client throws on a
+ * 401, the hook swallowed it (`data?.items ?? []`), and an expired session was
+ * indistinguishable from a collection holding nothing — the reading the
+ * no-silent-auth-failure rule exists to forbid.
+ *
+ * "Load more" was dead under a query: the button read `hasNextPage` off the
+ * listing query while the rows came from the search one, so it either did not
+ * appear or fetched a page nothing rendered.
+ *
+ * And the empty state flashed: `listState` read the listing's loading flag, so
+ * a cached listing beside an in-flight search said "no matches" before the
+ * search had answered.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import {
+	type AnyRouter,
+	createMemoryHistory,
+	createRootRoute,
+	createRoute,
+	createRouter,
+	Outlet,
+	RouterProvider,
+} from "@tanstack/react-router";
+import { createElement } from "react";
+import { ComposeProvider } from "@/components/compose/ComposeProvider";
+import { MailContext, type MailContextValue } from "@/lib/mail-context";
+import { MailFreshnessProvider } from "@/lib/mail-freshness";
+import { EMPTY_RESULT_FOLDER_INDEX } from "@/lib/result-folder";
+import { useOpenThreadPath } from "@/routing";
+import { createDomHarness, type DomHarness } from "@/test-support/dom";
+import { makeThreadMessage } from "@/test-support/fixtures";
+import {
+	type HttpCall,
+	type HttpMock,
+	httpError,
+	mockFetch,
+} from "@/test-support/http";
+import { FlaggedPane } from "./FlaggedPane";
+
+const QUERY = "concierge";
+const DESKTOP_WIDTH = 1440;
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+});
+
+// The router reads `self` at construction; the shared jsdom globals stop at
+// `window`.
+(globalThis as { self?: typeof globalThis }).self ??= globalThis;
+
+const match = (index: number): RemitImapThreadMessageResponse =>
+	makeThreadMessage({
+		messageId: `match-${index}`,
+		threadId: `thread-match-${index}`,
+		subject: `Parcel ${index}`,
+		snippet: "Your parcel was left with the concierge",
+		hasStars: true,
+		sentDate: 1_767_225_600_000 - index * 1_000,
+	});
+
+/** A full page, so the server hands back a continuation token with it. */
+const FIRST_PAGE = Array.from({ length: 50 }, (_, index) => match(index));
+const SECOND_PAGE = [match(50)];
+
+const mailContext = (query: string): MailContextValue => ({
+	accounts: [],
+	mailboxNameIndex: new Map(),
+	accountNameIndex: new Map(),
+	resultFolderIndex: EMPTY_RESULT_FOLDER_INDEX,
+	searchQuery: query,
+	searchInput: query,
+	searchViewKey: "list",
+	onSearchChange: () => undefined,
+	onSearchClear: () => undefined,
+	onSearchClearQuery: () => undefined,
+	intelligenceOpen: false,
+	onToggleIntelligence: () => undefined,
+	onRaiseIntelligence: () => undefined,
+});
+
+const testRouter = (query: string): AnyRouter => {
+	const rootRoute = createRootRoute({
+		component: () =>
+			createElement(MailFreshnessProvider, {
+				accountIds: [],
+				// biome-ignore lint/correctness/noChildrenProp: no JSX in a `.ts` test, and createElement's variadic children do not satisfy a required prop
+				children: createElement(
+					MailContext.Provider,
+					{ value: mailContext(query) },
+					createElement(ComposeProvider, null, createElement(Outlet)),
+				),
+			}),
+	});
+	const mailRoute = createRoute({
+		getParentRoute: () => rootRoute,
+		path: "/mail",
+		validateSearch: (search: Record<string, unknown>) => search,
+		component: Outlet,
+	});
+	const flaggedRoute = createRoute({
+		getParentRoute: () => mailRoute,
+		path: "/flagged",
+		component: () =>
+			createElement(FlaggedPane, {
+				thread: useOpenThreadPath(),
+				// biome-ignore lint/correctness/noChildrenProp: no JSX in a `.ts` test, and createElement's variadic children do not satisfy a required prop
+				children: createElement(FlaggedPane.List),
+			}),
+	});
+	const routeTree = rootRoute.addChildren([
+		mailRoute.addChildren([flaggedRoute]),
+	]);
+	return createRouter({
+		routeTree,
+		history: createMemoryHistory({ initialEntries: ["/mail/flagged"] }),
+	}) as unknown as AnyRouter;
+};
+
+const threadCalls = (): HttpCall[] =>
+	(http?.calls ?? []).filter(
+		(call) => new URL(call.url, "http://localhost").pathname === "/threads",
+	);
+
+const paramsOf = (call: HttpCall): URLSearchParams =>
+	new URL(call.url, "http://localhost").searchParams;
+
+const mount = async (
+	answer: (call: HttpCall) => unknown,
+	query = QUERY,
+): Promise<DomHarness> => {
+	http = mockFetch((call) => {
+		if (call.path.endsWith("/config")) return { accounts: [] };
+		if (call.path !== "/threads") return { items: [] };
+		return answer(call);
+	});
+
+	const router = testRouter(query);
+	await router.load();
+	const mounted = createDomHarness({ viewportWidth: DESKTOP_WIDTH });
+	harness = mounted;
+	mounted.renderApp(createElement(RouterProvider, { router }));
+	await mounted.flush();
+	await mounted.wait(20);
+	await mounted.flush();
+	return mounted;
+};
+
+/** The rows request: the count reads `results=false` and carries no rows. */
+const isRowRequest = (call: HttpCall): boolean =>
+	paramsOf(call).get("results") !== "false";
+
+describe("a Starred search reaches the whole collection (#1128, #1135)", () => {
+	// The failure the no-silent-auth-failure rule names: a 401 that renders as
+	// an empty result is indistinguishable from a collection holding nothing, so
+	// the reader concludes their mail is gone rather than their session.
+	it("says a failed search failed, never that nothing matched", async () => {
+		// Only the search fails. The pane's own unnarrowed listing answers, which
+		// is what let the failure hide: the view read its error state off that
+		// healthy query while rendering rows from the failed one.
+		const mounted = await mount((call) =>
+			isRowRequest(call) && paramsOf(call).get("query")
+				? httpError(401, "Session expired")
+				: { items: [] },
+		);
+
+		await mounted.waitFor(
+			() => mounted.text().includes("Couldn't load messages"),
+			"the failed search to state itself",
+		);
+
+		const shown = mounted.text();
+		assert.ok(
+			!/No .*matching/i.test(shown) && !/No messages in Starred/.test(shown),
+			`a failed search rendered as an empty collection: ${shown.slice(0, 300)}`,
+		);
+		assert.ok(
+			[...mounted.queryAll("button")].some(
+				(button) => (button.textContent ?? "").trim() === "Retry",
+			),
+			"the failure offered no way to retry",
+		);
+	});
+
+	// The dead button: the rows came from a query with no continuation, so the
+	// control that asks for more of them had nothing to ask.
+	it("pages a search past its first page", async () => {
+		const mounted = await mount((call) => {
+			if (!isRowRequest(call)) return { count: FIRST_PAGE.length + 1 };
+			return paramsOf(call).get("continuationToken")
+				? { items: SECOND_PAGE }
+				: { items: FIRST_PAGE, continuationToken: "page-2" };
+		});
+
+		await mounted.waitFor(
+			() => mounted.text().includes("Parcel 0"),
+			"the first page of matches",
+		);
+
+		const loadMore = [...mounted.queryAll("button")].find((button) =>
+			(button.textContent ?? "").includes("Load more"),
+		);
+		assert.ok(loadMore, "a search with more matches offered no way to them");
+
+		mounted.click(loadMore);
+		await mounted.waitFor(
+			() => mounted.text().includes("Parcel 50"),
+			"the second page of matches",
+		);
+
+		const paged = threadCalls().filter(
+			(call) => isRowRequest(call) && paramsOf(call).get("continuationToken"),
+		);
+		assert.equal(paged.length, 1, "the second page was never requested");
+		assert.equal(
+			paramsOf(paged[0]).get("query"),
+			QUERY,
+			"the next page dropped the search text",
+		);
+	});
+
+	// One request answers the rows under a query, so the free text travels with
+	// every other criterion rather than in a second query beside them. (The pane
+	// keeps its own unnarrowed listing for selection resolution; that one carries
+	// no text and is not this.)
+	it("asks for the matches once, on the listing request", async () => {
+		const mounted = await mount(() => ({ items: FIRST_PAGE.slice(0, 2) }));
+		await mounted.waitFor(
+			() => mounted.text().includes("Parcel 0"),
+			"the matches to render",
+		);
+
+		const searched = threadCalls().filter(
+			(call) => isRowRequest(call) && paramsOf(call).get("query") === QUERY,
+		);
+		assert.equal(searched.length, 1, "the search fanned out into two requests");
+		assert.equal(paramsOf(searched[0]).get("starred"), "true");
+	});
+
+	// The reach sentence is read off the request. A narrowing token beside the
+	// free text is what puts the sentence on screen, and both are parameters
+	// now, so the honest claim is the whole collection — which is only true
+	// because the search pages to its end rather than stopping at one window.
+	it("claims the whole collection was checked when nothing matched", async () => {
+		const mounted = await mount(
+			(call) => (isRowRequest(call) ? { items: [] } : { count: 0 }),
+			`is:unread ${QUERY}`,
+		);
+
+		await mounted.waitFor(
+			() => mounted.text().includes("No "),
+			"the empty search to settle",
+		);
+		assert.match(mounted.text(), /Every message in this folder was checked\./);
+	});
+});

package/src/hooks/useBriefSections.ts

@@ -47,7 +47,7 @@ import type { ResultCount } from "@remit/ui";
 import { useQueries, useQuery } from "@tanstack/react-query";
 import { useCallback, useMemo } from "react";
 import type { BriefSectionParams } from "@/lib/brief-criteria";
-import { type InboxFilterParams, sameInboxFilter } from "@/lib/inbox-filters";
+import { type ListFilterParams, sameInboxFilter } from "@/lib/inbox-filters";
 import { toResultCount } from "@/lib/result-count";
 
 /** A minute: a brief reopened straight away costs nothing. */
@@ -66,7 +66,7 @@ const UNCOUNTED: ResultCount = { kind: "unknown" };
  * is what `sameInboxFilter` was written to stop (design D18).
  */
 const keepUnderSameFilter =
-	(filter: InboxFilterParams) =>
+	(filter: ListFilterParams) =>
 	(
 		previous: RemitImapThreadSearchResponse | undefined,
 		previousQuery: { queryKey: readonly unknown[] } | undefined,
@@ -75,7 +75,10 @@ const keepUnderSameFilter =
 
 /** The criteria every section request carries, its own category aside. */
 export interface BriefSectionsCriteria extends BriefSectionParams {
-	/** Committed free text, matched against subject and From across folders. */
+	/**
+	 * Committed free text, matched against subject, From and the body preview
+	 * across folders.
+	 */
 	query?: string;
 }
 
@@ -111,13 +114,19 @@ const sectionCountQuery = (
 const sectionFilter = (
 	criteria: BriefSectionsCriteria,
 	category: RemitImapMessageCategory,
-): InboxFilterParams => ({
+): ListFilterParams => ({
 	category: [category],
 	...(criteria.unread !== undefined ? { unread: criteria.unread } : {}),
 	...(criteria.starred !== undefined ? { starred: criteria.starred } : {}),
 	...(criteria.attachments !== undefined
 		? { attachments: criteria.attachments }
 		: {}),
+	// The account pill is a scope, not text: switching it must take the previous
+	// account's rows off screen rather than render them for one round trip.
+	...(criteria.accountId !== undefined
+		? { accountId: criteria.accountId }
+		: {}),
+	...(criteria.muted !== undefined ? { muted: criteria.muted } : {}),
 });
 
 export interface BriefSectionRows {