@remit/web-client 0.0.86 → 0.0.87

package/src/hooks/useInitialSyncProgress.render.test.ts

@@ -0,0 +1,280 @@
+/**
+ * "Still arriving" is a claim about the server, so it is read from the sync
+ * phase the IMAP worker writes — never guessed from an empty list. What the
+ * tests pin is when the hook is allowed to speak at all: it stays unresolved
+ * until every account has answered, an unreachable account counts as answered
+ * rather than holding the list in limbo, and a phase it does not recognise is
+ * not syncing.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type {
+	RemitImapAccountSyncStatusResponse,
+	RemitImapSyncPhase,
+} from "@remit/api-http-client/types.gen.ts";
+import { createElement } from "react";
+import { createDomHarness, type DomHarness } from "../test-support/dom";
+import { type HttpMock, httpError, mockFetch } from "../test-support/http";
+import {
+	ANSWER_DEADLINE_MS,
+	type InitialSyncProgress,
+	isSyncingPhase,
+	POLL_MS,
+	useInitialSyncProgress,
+} from "./useInitialSyncProgress";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+});
+
+interface MailboxProgress {
+	synced: number;
+	total: number;
+}
+
+const status = (
+	accountId: string,
+	syncPhase: RemitImapSyncPhase | undefined,
+	mailboxes: MailboxProgress[] = [],
+): RemitImapAccountSyncStatusResponse => ({
+	accountId,
+	...(syncPhase ? { syncPhase } : {}),
+	mailboxes: mailboxes.map((mailbox, index) => ({
+		mailboxId: `mbx-${accountId}-${index}`,
+		fullPath: index === 0 ? "INBOX" : `Folder ${index}`,
+		phase: "syncing",
+		messagesSynced: mailbox.synced,
+		messagesTotal: mailbox.total,
+	})),
+});
+
+function Probe({
+	accountIds,
+	enabled,
+}: {
+	accountIds: string[];
+	enabled: boolean;
+}) {
+	const progress = useInitialSyncProgress(accountIds, enabled);
+	return createElement("div", null, JSON.stringify(progress));
+}
+
+/** The account id in `/accounts/{id}/sync/status`. */
+const accountOf = (path: string): string => path.split("/")[2] ?? "";
+
+const mount = async (
+	accountIds: string[],
+	answer: (accountId: string) => unknown,
+	enabled = true,
+): Promise<DomHarness> => {
+	http = mockFetch((call) => answer(accountOf(call.path)));
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe, { accountIds, enabled }));
+	await harness.flush();
+	await harness.flush();
+	return harness;
+};
+
+const progress = (dom: DomHarness): InitialSyncProgress =>
+	JSON.parse(dom.text());
+
+describe("isSyncingPhase", () => {
+	it("is true only for the phases a running sync round writes", () => {
+		assert.equal(isSyncingPhase("discovering_mailboxes"), true);
+		assert.equal(isSyncingPhase("syncing_inbox"), true);
+		assert.equal(isSyncingPhase("syncing_others"), true);
+	});
+
+	it("is false for idle, complete, and error", () => {
+		assert.equal(isSyncingPhase("idle"), false);
+		assert.equal(isSyncingPhase("complete"), false);
+		assert.equal(isSyncingPhase("error"), false);
+	});
+
+	it("is false for an account row written before the phase existed", () => {
+		// "Not complete" would read this as syncing forever.
+		assert.equal(isSyncingPhase(undefined), false);
+	});
+});
+
+describe("useInitialSyncProgress", () => {
+	it("reports syncing with the counts of the accounts still syncing", async () => {
+		const dom = await mount(["acc-1"], (accountId) =>
+			status(accountId, "syncing_inbox", [
+				{ synced: 40, total: 100 },
+				{ synced: 10, total: 60 },
+			]),
+		);
+		assert.deepEqual(progress(dom), {
+			syncing: true,
+			resolved: true,
+			synced: 50,
+			total: 160,
+		});
+	});
+
+	it("leaves out the counts of an account that has finished", async () => {
+		const dom = await mount(["acc-1", "acc-2"], (accountId) =>
+			accountId === "acc-1"
+				? status(accountId, "syncing_inbox", [{ synced: 40, total: 100 }])
+				: status(accountId, "complete", [{ synced: 900, total: 900 }]),
+		);
+		assert.deepEqual(progress(dom), {
+			syncing: true,
+			resolved: true,
+			synced: 40,
+			total: 100,
+		});
+	});
+
+	it("resolves to not-syncing once every account is done", async () => {
+		const dom = await mount(["acc-1", "acc-2"], (accountId) =>
+			status(accountId, "complete", [{ synced: 900, total: 900 }]),
+		);
+		assert.deepEqual(progress(dom), {
+			syncing: false,
+			resolved: true,
+			synced: 0,
+			total: 0,
+		});
+	});
+
+	it("counts an unreachable account as answered rather than holding the list in limbo", async () => {
+		const dom = await mount(["acc-1", "acc-2"], (accountId) =>
+			accountId === "acc-1"
+				? status(accountId, "syncing_inbox", [{ synced: 5, total: 50 }])
+				: httpError(503),
+		);
+		const state = progress(dom);
+		assert.equal(state.resolved, true);
+		assert.equal(state.syncing, true);
+		assert.equal(state.synced, 5);
+	});
+
+	it("knows nothing until every account has answered", async () => {
+		// One account answers, the other never does — the hook must not report on
+		// the half it has.
+		const original = globalThis.fetch;
+		try {
+			globalThis.fetch = ((input: RequestInfo | URL) => {
+				const url = input instanceof Request ? input.url : String(input);
+				if (url.includes("acc-2")) return new Promise<Response>(() => {});
+				return Promise.resolve(
+					new Response(
+						JSON.stringify(
+							status("acc-1", "syncing_inbox", [{ synced: 5, total: 50 }]),
+						),
+						{ status: 200, headers: { "content-type": "application/json" } },
+					),
+				);
+			}) as typeof globalThis.fetch;
+			harness = createDomHarness();
+			harness.renderApp(
+				createElement(Probe, { accountIds: ["acc-1", "acc-2"], enabled: true }),
+			);
+			await harness.flush();
+			await harness.flush();
+			assert.deepEqual(progress(harness), {
+				syncing: false,
+				resolved: false,
+				synced: 0,
+				total: 0,
+			});
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("answers immediately, and never syncing, for no accounts at all", async () => {
+		const dom = await mount([], () => ({}));
+		assert.deepEqual(progress(dom), {
+			syncing: false,
+			resolved: true,
+			synced: 0,
+			total: 0,
+		});
+		assert.deepEqual(http?.calls ?? [], []);
+	});
+
+	it("stops asking once every account has answered and none is syncing", async () => {
+		// The caught-up user's answer cannot change by being asked again.
+		const dom = await mount(["acc-1", "acc-2"], (accountId) =>
+			status(accountId, "complete"),
+		);
+		const asked = http?.calls.length ?? 0;
+		assert.equal(asked, 2);
+
+		await dom.wait(POLL_MS + 500);
+
+		assert.equal(http?.calls.length, asked);
+		assert.equal(progress(dom).resolved, true);
+	});
+
+	it("keeps asking while an account is still syncing", async () => {
+		const dom = await mount(["acc-1"], (accountId) =>
+			status(accountId, "syncing_inbox", [{ synced: 5, total: 50 }]),
+		);
+
+		await dom.wait(POLL_MS + 500);
+
+		assert.ok(
+			(http?.calls.length ?? 0) > 1,
+			"progress has to keep arriving while the sync runs",
+		);
+	});
+
+	it("answers without an account that never responds", async () => {
+		const original = globalThis.fetch;
+		try {
+			globalThis.fetch = ((input: RequestInfo | URL) => {
+				const url = input instanceof Request ? input.url : String(input);
+				if (url.includes("acc-2")) return new Promise<Response>(() => {});
+				return Promise.resolve(
+					new Response(JSON.stringify(status("acc-1", "complete")), {
+						status: 200,
+						headers: { "content-type": "application/json" },
+					}),
+				);
+			}) as typeof globalThis.fetch;
+			harness = createDomHarness();
+			harness.renderApp(
+				createElement(Probe, { accountIds: ["acc-1", "acc-2"], enabled: true }),
+			);
+			await harness.flush();
+			assert.equal(progress(harness).resolved, false);
+
+			await harness.wait(ANSWER_DEADLINE_MS + 500);
+
+			assert.deepEqual(progress(harness), {
+				syncing: false,
+				resolved: true,
+				synced: 0,
+				total: 0,
+			});
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
+
+	it("asks nothing and claims nothing while disabled", async () => {
+		const dom = await mount(
+			["acc-1"],
+			() => status("acc-1", "syncing_inbox"),
+			false,
+		);
+		assert.deepEqual(progress(dom), {
+			syncing: false,
+			resolved: false,
+			synced: 0,
+			total: 0,
+		});
+		assert.deepEqual(http?.calls ?? [], []);
+	});
+});

package/src/hooks/useInitialSyncProgress.ts

@@ -0,0 +1,134 @@
+import { syncOperationsGetSyncStatusOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type { RemitImapSyncPhase } from "@remit/api-http-client/types.gen.ts";
+import { useQueries } from "@tanstack/react-query";
+import { useEffect, useState } from "react";
+
+/**
+ * The phases the server writes while a sync round is actually running.
+ *
+ * A set of the in-progress values rather than "not complete": an account row
+ * written before the phase existed reads back `undefined`, and `idle` means no
+ * sync is running. Both would otherwise pin a list to "still syncing" forever,
+ * which is the same dishonesty as the bug in the other direction.
+ */
+const IN_PROGRESS: ReadonlySet<RemitImapSyncPhase> = new Set([
+	"discovering_mailboxes",
+	"syncing_inbox",
+	"syncing_others",
+]);
+
+/** Whether a phase reading means the server is mid-sync right now. */
+export function isSyncingPhase(phase: RemitImapSyncPhase | undefined): boolean {
+	return !!phase && IN_PROGRESS.has(phase);
+}
+
+export const POLL_MS = 3000;
+
+/**
+ * How long an account may stay silent before the answer is given without it.
+ *
+ * An account that errors counts as answered; one that never responds does not,
+ * and without a bound a single hung account holds the brief on its skeleton for
+ * as long as the tab is open — it would never say "You're caught up". Two poll
+ * rounds is long enough that a slow-but-alive account still gets to speak.
+ */
+export const ANSWER_DEADLINE_MS = POLL_MS * 2;
+
+export interface InitialSyncProgress {
+	/** At least one account reports an in-progress sync phase. */
+	syncing: boolean;
+	/** Every enabled sync-status query has answered; until then nothing is known. */
+	resolved: boolean;
+	/** Messages downloaded so far, summed over the accounts still syncing. */
+	synced: number;
+	/** What those accounts hold in total; 0 while the server has not counted. */
+	total: number;
+}
+
+const UNKNOWN: InitialSyncProgress = {
+	syncing: false,
+	resolved: false,
+	synced: 0,
+	total: 0,
+};
+
+/**
+ * Whether any of these accounts is mid-sync, read from the account sync-status
+ * endpoint (`syncPhase`) — a real server-side state the IMAP worker writes, not
+ * a guess from message counts. The per-mailbox message numbers alongside it are
+ * approximate by the API's own definition (a UID-range estimate), so they are
+ * only ever shown as progress, never as a total the UI reasons about.
+ *
+ * `enabled` exists because the answer only matters when something is about to
+ * be claimed about an empty result; polling every account continuously to
+ * answer a question nobody asked is not worth the requests.
+ *
+ * The poll is a question with a last answer. Once every account has spoken and
+ * none is mid-sync, nothing further can change the reading, so the polling
+ * stops there rather than re-asking every three seconds for the rest of the
+ * session — the caught-up user was paying about 1,200 requests an hour per
+ * account for an answer that was already final. A new account set asks again.
+ */
+export function useInitialSyncProgress(
+	accountIds: string[],
+	enabled: boolean,
+): InitialSyncProgress {
+	const accountKey = accountIds.join(",");
+	const [settled, setSettled] = useState(false);
+	const [deadlinePassed, setDeadlinePassed] = useState(false);
+
+	// A different account set is a different question: it gets its own answer,
+	// its own deadline, and a poll that runs again until it has one.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: accountKey/enabled are trigger-only — the reset is unconditional, not a value read from either.
+	useEffect(() => {
+		setSettled(false);
+		setDeadlinePassed(false);
+	}, [accountKey, enabled]);
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: accountKey restarts the deadline for a new question rather than being read inside it.
+	useEffect(() => {
+		if (!enabled) return;
+		const timer = setTimeout(() => setDeadlinePassed(true), ANSWER_DEADLINE_MS);
+		return () => clearTimeout(timer);
+	}, [accountKey, enabled]);
+
+	const queries = useQueries({
+		queries: accountIds.map((accountId) => ({
+			...syncOperationsGetSyncStatusOptions({ path: { accountId } }),
+			// Disabling keeps the cached answer and its success/error status; it
+			// only stops the interval.
+			enabled: enabled && !settled,
+			refetchInterval: POLL_MS,
+			// A failed sync-status read is not the account failing — it must not
+			// raise the global fatal overlay over a question about an empty list.
+			meta: { softError: true },
+		})),
+	});
+
+	// A query that errored still counts as answered: the caller's fallback is the
+	// same either way, and one unreachable account must not hold the whole list
+	// in limbo. One that never answers at all is covered by the deadline instead.
+	const answered = queries.every((q) => q.isSuccess || q.isError);
+	const resolved = queries.length === 0 || answered || deadlinePassed;
+
+	let syncing = false;
+	let synced = 0;
+	let total = 0;
+	for (const query of queries) {
+		if (!isSyncingPhase(query.data?.syncPhase)) continue;
+		syncing = true;
+		for (const mailbox of query.data?.mailboxes ?? []) {
+			synced += mailbox.messagesSynced;
+			total += mailbox.messagesTotal;
+		}
+	}
+
+	const final = enabled && resolved && !syncing;
+	useEffect(() => {
+		if (final) setSettled(true);
+	}, [final]);
+
+	if (!enabled) return UNKNOWN;
+	if (!resolved) return UNKNOWN;
+	return { syncing, resolved: true, synced, total };
+}

package/src/hooks/useListCursor.ts

@@ -34,6 +34,13 @@ interface UseListCursorOptions {
 export interface ListCursor {
 	focusedMessageId: string | undefined;
 	setFocusedMessageId: (id: string | undefined) => void;
+	/**
+	 * The row a keyboard command last moved the cursor onto, and `undefined`
+	 * whenever the cursor last moved some other way. Drives the reading pane
+	 * following the cursor (`useFollowFocusOpen`) — a click and Enter open on
+	 * their own, so only a bare cursor move is left to follow.
+	 */
+	keyboardFocusedMessageId: string | undefined;
 	focusIndex: number;
 	pendingDomFocusRef: React.RefObject<string | null>;
 	cursorMovedByPointerRef: React.RefObject<boolean>;
@@ -67,13 +74,32 @@ export const useListCursor = ({
 	onExitSelection,
 }: UseListCursorOptions): ListCursor => {
 	// The keyboard "where am I" pointer, distinct from the open thread
-	// (`selectedMessageId` in the URL). j/k move this cursor without opening;
-	// Enter opens the focused row. It seeds from the open thread so opening a
+	// (`selectedMessageId` in the URL). j/k move this cursor; Enter opens the
+	// focused row, and on desktop the reading pane follows the cursor of its own
+	// accord (`useFollowFocusOpen`). It seeds from the open thread so opening a
 	// message also focuses its row.
-	const [focusedMessageId, setFocusedMessageId] = useState<string | undefined>(
+	const [focusedMessageId, setFocusedId] = useState<string | undefined>(
 		initialFocusedId,
 	);
 
+	// Which of those moves came from a keyboard command, so the reading pane can
+	// follow the cursor without following a click that already opened its own row.
+	const [keyboardFocusedMessageId, setKeyboardFocusedMessageId] = useState<
+		string | undefined
+	>();
+
+	// Every non-keyboard move — a click, Tab, a thread opening, a refetch snapping
+	// the cursor to a survivor — drops the keyboard mark, so nothing follows it.
+	// A row taking DOM focus as the *consequence* of a keyboard move arrives here
+	// with the id that move just set; keeping the mark in that case is what stops
+	// the browser's own focus event from cancelling the load the move started.
+	const setFocusedMessageId = useCallback((id: string | undefined) => {
+		setKeyboardFocusedMessageId((current) =>
+			current === id ? current : undefined,
+		);
+		setFocusedId(id);
+	}, []);
+
 	const selection = useSelection();
 	const {
 		selectedCount,
@@ -122,7 +148,8 @@ export const useListCursor = ({
 			}
 			pendingDomFocusRef.current = messageId;
 			cursorMovedByPointerRef.current = false;
-			setFocusedMessageId(messageId);
+			setKeyboardFocusedMessageId(messageId);
+			setFocusedId(messageId);
 		},
 		[orderedIds, isMultiSelectMode, toggleCheck],
 	);
@@ -191,7 +218,10 @@ export const useListCursor = ({
 			selectRange(orderedIds, target);
 			pendingDomFocusRef.current = target;
 			cursorMovedByPointerRef.current = false;
-			setFocusedMessageId(target);
+			// Shift+arrow is building a range, not reading. The reading pane stays on
+			// whatever is open rather than chasing the growing edge of the selection.
+			setKeyboardFocusedMessageId(undefined);
+			setFocusedId(target);
 		},
 		[orderedIds, focusedMessageId, selectRange],
 	);
@@ -206,6 +236,7 @@ export const useListCursor = ({
 	return {
 		focusedMessageId,
 		setFocusedMessageId,
+		keyboardFocusedMessageId,
 		focusIndex,
 		pendingDomFocusRef,
 		cursorMovedByPointerRef,

package/src/hooks/useMarkAsRead.ts

@@ -8,6 +8,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
+import { runChunkedMutation } from "@/lib/bulk-actions";
 import {
 	cancelThreadListQueries,
 	invalidateThreadListQueries,
@@ -298,7 +299,7 @@ export const useToggleReadFor = (options: {
 	const queryClient = useQueryClient();
 	const { pushError } = useErrorBanners();
 
-	const { mutate, isPending } = useMutation({
+	const { mutateAsync, isPending } = useMutation({
 		...messageBulkOperationsUpdateFlagsMutation(),
 		onError: (error, variables) => {
 			const isRead = variables.body.isRead ?? true;
@@ -332,9 +333,11 @@ export const useToggleReadFor = (options: {
 	const toggleReadFor = useCallback(
 		(messageIds: string[], isRead: boolean) => {
 			if (messageIds.length === 0) return;
-			mutate({ body: { messageIds, isRead } });
+			void runChunkedMutation(messageIds, (chunk) =>
+				mutateAsync({ body: { messageIds: chunk, isRead } }),
+			);
 		},
-		[mutate],
+		[mutateAsync],
 	);
 
 	return { toggleReadFor, isPending };

package/src/hooks/useMoveMessages.ts

@@ -8,6 +8,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useCallback } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
+import { runChunkedMutation } from "@/lib/bulk-actions";
 import {
 	cancelThreadListQueries,
 	invalidateThreadListQueries,
@@ -70,7 +71,7 @@ export const useMoveMessages = ({
 	const queryClient = useQueryClient();
 	const { pushError } = useErrorBanners();
 
-	const { mutate, isPending } = useMutation({
+	const { mutateAsync, isPending } = useMutation({
 		...messageBulkOperationsMoveMessagesMutation(),
 		onMutate: async (variables): Promise<MoveContext> => {
 			const messageIds = new Set(variables.body.messageIds ?? []);
@@ -181,9 +182,11 @@ export const useMoveMessages = ({
 	const moveMessages = useCallback(
 		(messageIds: string[], destinationMailboxId: string) => {
 			if (messageIds.length === 0) return;
-			mutate({ body: { messageIds, destinationMailboxId } });
+			void runChunkedMutation(messageIds, (chunk) =>
+				mutateAsync({ body: { messageIds: chunk, destinationMailboxId } }),
+			);
 		},
-		[mutate],
+		[mutateAsync],
 	);
 
 	return { moveMessages, isPending };

package/src/hooks/useRulePreview.ts

@@ -5,9 +5,11 @@ import { useEffect, useRef, useState } from "react";
 import { buildOrganizeInput } from "@/lib/organize/organize-model";
 import {
 	derivePreview,
+	isEvaluablePredicate,
 	PREVIEW_DEBOUNCE_MS,
 	type PreviewState,
 	predicateSignature,
+	UNCOUNTABLE_PREDICATE_REASON,
 } from "@/lib/organize/rule-model";
 import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
 
@@ -45,9 +47,13 @@ export const useRulePreview = (
 	const predicateRef = useRef(predicate);
 	predicateRef.current = predicate;
 	const latestRequested = useRef(currentSignature);
+	// A predicate the matcher rejects outright is never sent — the request would
+	// 500, and a 500 is not a count. The editor says so instead and holds the
+	// commit for the scopes that would run this same matcher.
+	const countable = isEvaluablePredicate(predicate);
 
 	useEffect(() => {
-		if (!accountId) return;
+		if (!accountId || !countable) return;
 		if (currentSignature === state.previewedSignature) return;
 		if (currentSignature === state.errorSignature) return;
 
@@ -81,11 +87,15 @@ export const useRulePreview = (
 		return () => clearTimeout(handle);
 	}, [
 		accountId,
+		countable,
 		currentSignature,
 		state.previewedSignature,
 		state.errorSignature,
 		mutateAsync,
 	]);
 
+	if (!countable) {
+		return { status: "error", reason: UNCOUNTABLE_PREDICATE_REASON };
+	}
 	return derivePreview(state, currentSignature);
 };

package/src/hooks/useSearchFilterSeed.render.test.ts

@@ -28,28 +28,43 @@ afterEach(() => {
 	http = undefined;
 });
 
-const PREDICATE: OrganizeMatchPredicate = {
+const COUNTABLE: OrganizeMatchPredicate = {
+	matchOperator: "And",
+	literalClauses: [{ field: "From", value: "receipts@shop.example" }],
+};
+
+/**
+ * A free-text search converts to a body-content clause, which the vector-free
+ * matcher refuses. The seed must not ask.
+ */
+const UNCOUNTABLE: OrganizeMatchPredicate = {
 	matchOperator: "And",
 	literalClauses: [{ field: "HasWords", value: "receipts" }],
 };
 
-function Probe() {
-	const seed = useSearchFilterSeed("acc-1", PREDICATE);
-	return createElement(
-		"div",
-		null,
-		JSON.stringify({
-			seedCount: seed.seedCount ?? null,
-			isPending: seed.isPending,
-			isError: seed.isError,
-		}),
-	);
+function probeFor(predicate: OrganizeMatchPredicate) {
+	return function Probe() {
+		const seed = useSearchFilterSeed("acc-1", predicate);
+		return createElement(
+			"div",
+			null,
+			JSON.stringify({
+				seedCount: seed.seedCount ?? null,
+				isPending: seed.isPending,
+				isError: seed.isError,
+				uncountable: seed.uncountable,
+			}),
+		);
+	};
 }
 
-const mount = (responder: (call: HttpCall) => unknown): DomHarness => {
+const mount = (
+	responder: (call: HttpCall) => unknown,
+	predicate: OrganizeMatchPredicate = COUNTABLE,
+): DomHarness => {
 	http = mockFetch(responder);
 	harness = createDomHarness();
-	harness.renderApp(createElement(Probe));
+	harness.renderApp(createElement(probeFor(predicate)));
 	return harness;
 };
 
@@ -70,7 +85,7 @@ describe("useSearchFilterSeed", () => {
 		assert.equal(previews.length, 1);
 		assert.equal(previews[0].body?.anchorMessageId, undefined);
 		assert.deepEqual(previews[0].body?.literalClauses, [
-			{ field: "HasWords", value: "receipts" },
+			{ field: "From", value: "receipts@shop.example" },
 		]);
 	});
 
@@ -80,4 +95,24 @@ describe("useSearchFilterSeed", () => {
 		await dom.flush();
 		assert.equal(state(dom).isError, true);
 	});
+
+	it("never asks for a count the matcher cannot produce", async () => {
+		const dom = mount(
+			(call) =>
+				call.path.endsWith("/organize/preview")
+					? { matchedCount: 12, messageIds: [] }
+					: {},
+			UNCOUNTABLE,
+		);
+		await dom.flush();
+		await dom.flush();
+		assert.equal(http?.to("/organize/preview").length, 0);
+		// Not pending and not an error — the editor opens, it just has no number.
+		assert.deepEqual(state(dom), {
+			seedCount: null,
+			isPending: false,
+			isError: false,
+			uncountable: true,
+		});
+	});
 });