@remit/web-client 0.0.144 → 0.0.146

package/src/lib/mail-route.ts

@@ -1,61 +1,94 @@
 /**
- * Route detection for the /mail shell.
+ * Which list the router is showing, and whether a location still sits on one.
  *
- * `mail.tsx` mounts the right pane (brief, mailbox, or outbox) into
- * `AppShellSlotted` by inspecting the router's matched routes. The parent
- * `/mail` layout route is matched on EVERY child route, and its matched
- * `pathname` is "/mail" everywhere — so detection MUST key off each leaf
- * route's own `routeId`, never the parent pathname. Keying off "/mail"
- * pathname routed every mailbox through the brief pane, which renders the
- * unified DailyBrief instead of the mailbox MessageList — so the message
- * rows (the `a[href*=selectedMessageId]` anchors) vanished. These pure
- * predicates pin that contract.
+ * Every mail URL is a list plus, below it, whatever that list has open. The
+ * list is a layout route, so it is named by a matched route id: the parent
+ * `/mail` match carries the pathname "/mail" on every child, and the deepest
+ * match is the thread. A thread opened from the brief and the brief itself
+ * resolve to the same list.
  */
 
-/** A matched route, minimal shape needed for pane detection. */
+/** A matched route, minimal shape needed to identify the list. */
 export interface MailRouteMatch {
 	routeId: string;
 	params?: Record<string, string | undefined>;
 }
 
-/** The leaf route ids the /mail shell branches on. */
-export const MAIL_BRIEF_ROUTE_ID = "/mail/" as const;
+/** The list layout route ids. */
+export const MAIL_BRIEF_ROUTE_ID = "/mail/brief" as const;
 export const MAIL_MAILBOX_ROUTE_ID = "/mail/$mailboxId" as const;
 export const MAIL_OUTBOX_ROUTE_ID = "/mail/outbox" as const;
 export const MAIL_FLAGGED_ROUTE_ID = "/mail/flagged" as const;
 
-/** True only on the brief index route (/mail/), never on a mailbox/outbox. */
-export function isBriefRoute(matches: readonly MailRouteMatch[]): boolean {
-	return matches.some((m) => m.routeId === MAIL_BRIEF_ROUTE_ID);
-}
+/**
+ * The list a location is browsing. A mailbox route carries its id, which is
+ * absent only in the frame before the router has resolved the param.
+ */
+export type MailListRoute =
+	| { list: "brief" }
+	| { list: "flagged" }
+	| { list: "outbox" }
+	| { list: "mailbox"; mailboxId: string | undefined };
 
-/** True only on the flagged virtual-mailbox route (/mail/flagged). */
-export function isFlaggedRoute(matches: readonly MailRouteMatch[]): boolean {
-	return matches.some((m) => m.routeId === MAIL_FLAGGED_ROUTE_ID);
+/**
+ * The list layout among the matched routes, or `undefined` outside the mail
+ * shell.
+ *
+ * Reads the shallowest list match, so anything mounted under a list — the open
+ * thread, the message, the compose surface — leaves the answer alone.
+ */
+export function mailListRoute(
+	matches: readonly MailRouteMatch[],
+): MailListRoute | undefined {
+	for (const match of matches) {
+		if (match.routeId === MAIL_BRIEF_ROUTE_ID) return { list: "brief" };
+		if (match.routeId === MAIL_FLAGGED_ROUTE_ID) return { list: "flagged" };
+		if (match.routeId === MAIL_OUTBOX_ROUTE_ID) return { list: "outbox" };
+		if (match.routeId === MAIL_MAILBOX_ROUTE_ID)
+			return { list: "mailbox", mailboxId: match.params?.mailboxId };
+	}
+	return undefined;
 }
 
-/** True only on the outbox route. */
-export function isOutboxRoute(matches: readonly MailRouteMatch[]): boolean {
-	return matches.some((m) => m.routeId === MAIL_OUTBOX_ROUTE_ID);
+/**
+ * Identity of the list view the shell is showing — one mailbox, the brief, the
+ * flagged list, or the outbox. Opening a thread is not a view change, so the
+ * key of a list and of anything nested under it are equal; `lib/search-view.ts`
+ * re-seeds the search field whenever this changes, and a key that moved when a
+ * message opened would wipe the query the reader had just typed.
+ */
+export function mailViewKey(matches: readonly MailRouteMatch[]): string {
+	const route = mailListRoute(matches);
+	if (!route) return "";
+	switch (route.list) {
+		case "mailbox":
+			return route.mailboxId ? mailboxViewKey(route.mailboxId) : "";
+		case "flagged":
+			return MAIL_FLAGGED_ROUTE_ID;
+		case "outbox":
+			return MAIL_OUTBOX_ROUTE_ID;
+		case "brief":
+			return MAIL_BRIEF_ROUTE_ID;
+	}
 }
 
-/** True only on a mailbox route (/mail/$mailboxId). */
-export function isMailboxRoute(matches: readonly MailRouteMatch[]): boolean {
-	return matches.some((m) => m.routeId === MAIL_MAILBOX_ROUTE_ID);
+/** One mailbox's view key. Two mailboxes are two views. */
+export function mailboxViewKey(mailboxId: string): string {
+	return `${MAIL_MAILBOX_ROUTE_ID}:${mailboxId}`;
 }
 
 /**
- * Identity of the list view the shell is showing — one mailbox, the brief, the
- * flagged list, or the outbox. Two locations share a key when they differ only
- * in search params (opening a result, mirroring `q`), so opening a hit is not a
- * view change while switching mailbox is. `lib/search-view.ts` re-seeds the
- * search field whenever this changes.
+ * Whether a location sits on a list, or on something the list has open below it.
+ *
+ * Answers off the pathname rather than the matches on purpose. The router
+ * commits the new location before it swaps the matches, so a component leaving
+ * the screen sees its own matches under the destination's address for as long as
+ * the destination takes to mount. `pathname` is what says where the reader is
+ * going; `matches` is what says where they still are.
+ *
+ * `listPath` is a whole segment: a folder named `briefing` is not the brief.
  */
-export function mailViewKey(matches: readonly MailRouteMatch[]): string {
-	const mailboxId = matches.find((m) => m.params?.mailboxId)?.params?.mailboxId;
-	if (mailboxId) return `${MAIL_MAILBOX_ROUTE_ID}:${mailboxId}`;
-	if (isFlaggedRoute(matches)) return MAIL_FLAGGED_ROUTE_ID;
-	if (isOutboxRoute(matches)) return MAIL_OUTBOX_ROUTE_ID;
-	if (isBriefRoute(matches)) return MAIL_BRIEF_ROUTE_ID;
-	return "";
+export function locationIsOnList(pathname: string, listPath: string): boolean {
+	if (pathname === listPath) return true;
+	return pathname.startsWith(`${listPath}/`);
 }

package/src/lib/mail-search.ts

@@ -0,0 +1,51 @@
+/**
+ * The search params each mail list validates.
+ *
+ * `q` lives on the parent `/mail` route, but a child's `validateSearch` is
+ * authoritative for its own URL, so a child that omits `q` strips it: typing a
+ * query on that list does nothing and the query is lost on the next navigation.
+ * Every list extends the same base rather than re-declaring the param, so there
+ * is one place for it to be right.
+ */
+import { z } from "zod";
+
+/** What every list carries, whatever else it carries. */
+const listSearch = z.object({ q: z.string().optional() });
+
+export const briefSearchSchema = listSearch.extend({
+	selectedMessageId: z.string().optional(),
+	// A tapped semantic "Related" hit can point at a message outside the loaded
+	// brief list; carrying its thread + mailbox lets the brief open it directly.
+	selectedThreadId: z.string().optional(),
+	selectedMailboxId: z.string().optional(),
+});
+
+export const flaggedSearchSchema = listSearch.extend({
+	selectedMessageId: z.string().optional(),
+});
+
+export const outboxSearchSchema = listSearch.extend({
+	selectedOutboxMessageId: z.string().optional(),
+});
+
+export const mailboxSearchSchema = listSearch.extend({
+	selectedMessageId: z.string().optional(),
+	// A tapped semantic "Related" hit can point at a message outside the loaded
+	// list; carrying its thread lets the mailbox open it directly (the mailbox is
+	// the route param). See `buildConversationTarget`.
+	selectedThreadId: z.string().optional(),
+});
+
+/**
+ * `/mail` itself only redirects to the brief, so it accepts what the brief
+ * accepts and hands it straight on.
+ */
+export const mailIndexSearchSchema = briefSearchSchema;
+
+/** Every list's schema, by the path it validates. */
+export const mailListSearchSchemas = {
+	"/mail/brief": briefSearchSchema,
+	"/mail/flagged": flaggedSearchSchema,
+	"/mail/outbox": outboxSearchSchema,
+	"/mail/$mailboxId": mailboxSearchSchema,
+} as const;

package/src/lib/route-search-query.test.ts

@@ -1,38 +1,29 @@
 /**
- * `q` lives on the parent `/mail` route, but every child re-declares it: a
- * child's `validateSearch` is authoritative for its own URL, so a child that
- * omits `q` strips it. The top bar mounts a search field on all four of these
- * routes, so a stripped `q` means typing a query does nothing and the query is
- * lost on the next navigation.
+ * `q` lives on the parent `/mail` route, but every list re-declares it: a
+ * child's `validateSearch` is authoritative for its own URL, so a list that
+ * omits `q` strips it. The top bar mounts a search field on all four lists, so
+ * a stripped `q` means typing a query does nothing and the query is lost on the
+ * next navigation.
+ *
+ * Two halves: the schemas carry `q`, and each route is wired to the schema
+ * declared for its own path. The second half has to load route files, so it runs
+ * out of process — see `test-support/list-search-binding.ts`.
  */
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import { describe, it } from "node:test";
-import { z } from "zod";
-import { Route as MailboxRoute } from "../routes/mail/$mailboxId";
-import { Route as FlaggedRoute } from "../routes/mail/flagged";
-import { Route as BriefRoute } from "../routes/mail/index";
-import { Route as OutboxRoute } from "../routes/mail/outbox";
+import { fileURLToPath } from "node:url";
+import { mailIndexSearchSchema, mailListSearchSchemas } from "./mail-search.js";
 
-const routes = {
-	"/mail/ (daily brief)": BriefRoute,
-	"/mail/flagged": FlaggedRoute,
-	"/mail/outbox": OutboxRoute,
-	"/mail/$mailboxId": MailboxRoute,
+const schemas = {
+	...mailListSearchSchemas,
+	"/mail/ (the redirect to the brief)": mailIndexSearchSchema,
 };
 
-const parse = (route: { options: { validateSearch?: unknown } }) => {
-	const schema = route.options.validateSearch;
-	assert.ok(
-		schema instanceof z.ZodType,
-		"route must validate its search with a zod schema",
-	);
-	return (search: Record<string, unknown>) => schema.parse(search);
-};
-
-describe("every /mail child route carries `q` through its own validation", () => {
-	for (const [name, route] of Object.entries(routes)) {
+describe("every /mail list carries `q` through its own validation", () => {
+	for (const [name, schema] of Object.entries(schemas)) {
 		it(`${name} preserves a query`, () => {
-			const parsed = parse(route)({ q: "invoice" }) as { q?: string };
+			const parsed = schema.parse({ q: "invoice" }) as { q?: string };
 			assert.equal(
 				parsed.q,
 				"invoice",
@@ -41,8 +32,39 @@ describe("every /mail child route carries `q` through its own validation", () =>
 		});
 
 		it(`${name} leaves q absent when there is none`, () => {
-			const parsed = parse(route)({}) as { q?: string };
+			const parsed = schema.parse({}) as { q?: string };
 			assert.equal(parsed.q, undefined);
 		});
 	}
 });
+
+describe("every /mail list route uses the schema declared for its path", () => {
+	it("holds for all four lists", () => {
+		const check = fileURLToPath(
+			new URL("../test-support/list-search-binding.ts", import.meta.url),
+		);
+		const register = fileURLToPath(
+			new URL("../../test-support/register.mjs", import.meta.url),
+		);
+		// The runner re-injects its coverage directory into any child, even one
+		// given an environment without it, and coverage from this child would put
+		// every pane the route files reach into the denominator — the reason the
+		// check is out of process at all. An empty value is the one thing that
+		// stops the child writing there.
+		assert.doesNotThrow(() =>
+			execFileSync(
+				process.execPath,
+				["--import", "tsx", "--import", register, check],
+				{
+					stdio: "pipe",
+					encoding: "utf8",
+					env: {
+						...process.env,
+						NODE_V8_COVERAGE: "",
+						TSX_TSCONFIG_PATH: "./tsconfig.test.json",
+					},
+				},
+			),
+		);
+	});
+});

package/src/lib/search-scope.ts

@@ -11,7 +11,7 @@
  *
  * Removing the chip means "search everything", which is the daily brief — the
  * cross-account view whose scope is nothing. So removal is a navigation to
- * `/mail/` carrying the query, not an edit of the query text.
+ * `/mail/brief` carrying the query, not an edit of the query text.
  *
  * There is exactly one scope, and it is this one. A typed `in:` term is a
  * second, competing answer to "which mailbox", so it is recognized only where
@@ -22,14 +22,7 @@
  * Pure functions only. `useSearchScope` binds these to the router.
  */
 import type { FolderRole, SearchScope as ResultsScope } from "@remit/ui";
-import {
-	isBriefRoute,
-	isFlaggedRoute,
-	isMailboxRoute,
-	isOutboxRoute,
-	MAIL_MAILBOX_ROUTE_ID,
-	type MailRouteMatch,
-} from "./mail-route";
+import { type MailRouteMatch, mailListRoute } from "./mail-route";
 
 /**
  * Chip id of the scope chip. The top bar owns exactly one, so a fixed id is
@@ -72,9 +65,8 @@ export function scopeLabelForMailboxName(name: string): string {
  * not.
  */
 export function isScopedRoute(matches: readonly MailRouteMatch[]): boolean {
-	return (
-		isFlaggedRoute(matches) || isOutboxRoute(matches) || isMailboxRoute(matches)
-	);
+	const route = mailListRoute(matches);
+	return route !== undefined && route.list !== "brief";
 }
 
 /**
@@ -83,8 +75,8 @@ export function isScopedRoute(matches: readonly MailRouteMatch[]): boolean {
 export function routeMailboxId(
 	matches: readonly MailRouteMatch[],
 ): string | undefined {
-	return matches.find((m) => m.routeId === MAIL_MAILBOX_ROUTE_ID)?.params
-		?.mailboxId;
+	const route = mailListRoute(matches);
+	return route?.list === "mailbox" ? route.mailboxId : undefined;
 }
 
 /**
@@ -128,20 +120,20 @@ export function searchScopeForRoute(
 	matches: readonly MailRouteMatch[],
 	mailboxName?: string | null,
 ): SearchScopeState {
-	if (isBriefRoute(matches)) return { kind: "global" };
-	if (isFlaggedRoute(matches)) {
+	const route = mailListRoute(matches);
+	if (route?.list === "flagged") {
 		return {
 			kind: "scoped",
 			chip: { id: SEARCH_SCOPE_CHIP_ID, label: "is:starred" },
 		};
 	}
-	if (isOutboxRoute(matches)) {
+	if (route?.list === "outbox") {
 		return {
 			kind: "scoped",
 			chip: { id: SEARCH_SCOPE_CHIP_ID, label: "in:outbox" },
 		};
 	}
-	if (isMailboxRoute(matches)) {
+	if (route?.list === "mailbox") {
 		if (!mailboxName) return { kind: "pending" };
 		return {
 			kind: "scoped",
@@ -177,6 +169,6 @@ export function resultsScopeForRoute(
 	role?: FolderRole,
 ): ResultsScope {
 	if (state.kind === "global") return { kind: "global" };
-	if (isFlaggedRoute(matches)) return { kind: "collection" };
+	if (mailListRoute(matches)?.list === "flagged") return { kind: "collection" };
 	return { kind: "folder", ...(role ? { role } : {}) };
 }

package/src/lib/search-view.test.ts

@@ -6,7 +6,11 @@
  */
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { type MailRouteMatch, mailViewKey } from "./mail-route.js";
+import {
+	MAIL_BRIEF_ROUTE_ID,
+	type MailRouteMatch,
+	mailViewKey,
+} from "./mail-route.js";
 import {
 	committedSearchQuery,
 	searchInputForView,
@@ -19,31 +23,6 @@ const matches = (routeId: string, mailboxId?: string): MailRouteMatch[] => [
 	{ routeId, ...(mailboxId ? { params: { mailboxId } } : {}) },
 ];
 
-describe("mailViewKey", () => {
-	it("distinguishes two mailboxes", () => {
-		assert.notEqual(
-			mailViewKey(matches("/mail/$mailboxId", "inbox-1")),
-			mailViewKey(matches("/mail/$mailboxId", "archive-1")),
-		);
-	});
-
-	it("gives the same mailbox one key regardless of search params", () => {
-		assert.equal(
-			mailViewKey(matches("/mail/$mailboxId", "inbox-1")),
-			mailViewKey(matches("/mail/$mailboxId", "inbox-1")),
-		);
-	});
-
-	it("separates the brief, flagged and outbox views", () => {
-		const keys = [
-			mailViewKey(matches("/mail/")),
-			mailViewKey(matches("/mail/flagged")),
-			mailViewKey(matches("/mail/outbox")),
-		];
-		assert.equal(new Set(keys).size, 3);
-	});
-});
-
 describe("searchInputForView", () => {
 	it("clears the field when the destination carries no query", () => {
 		assert.equal(
@@ -71,7 +50,11 @@ describe("searchInputForView", () => {
 
 	it("seeds from the destination's own query (deep link, saved search)", () => {
 		assert.equal(
-			searchInputForView("/mail/$mailboxId:inbox-1", "/mail/", "invoice"),
+			searchInputForView(
+				"/mail/$mailboxId:inbox-1",
+				MAIL_BRIEF_ROUTE_ID,
+				"invoice",
+			),
 			"invoice",
 		);
 	});
@@ -89,12 +72,24 @@ describe("committedSearchQuery", () => {
 });
 
 describe("shouldMirrorQuery", () => {
+	/** A settled query on the brief, with the reader still on it. */
+	const onTheBrief = {
+		searchInput: "invoice",
+		committedQuery: "invoice",
+		urlQuery: "",
+		pathname: "/mail/brief",
+		listPath: "/mail/brief",
+	};
+
 	it("writes a settled query the URL does not have yet", () => {
-		assert.equal(shouldMirrorQuery("invoice", "invoice", ""), true);
+		assert.equal(shouldMirrorQuery(onTheBrief), true);
 	});
 
 	it("stays quiet once the URL already says it", () => {
-		assert.equal(shouldMirrorQuery("invoice", "invoice", "invoice"), false);
+		assert.equal(
+			shouldMirrorQuery({ ...onTheBrief, urlQuery: "invoice" }),
+			false,
+		);
 	});
 
 	it("does not strip the query a deep link just arrived with", () => {
@@ -102,11 +97,71 @@ describe("shouldMirrorQuery", () => {
 		// the committed query is still the previous view's. Writing it would drop
 		// `q` for the length of the debounce — and with it the search the link
 		// asked for.
-		assert.equal(shouldMirrorQuery("invoice", "", "invoice"), false);
+		assert.equal(
+			shouldMirrorQuery({
+				...onTheBrief,
+				committedQuery: "",
+				urlQuery: "invoice",
+			}),
+			false,
+		);
 	});
 
 	it("waits for the debounce while the user is still typing", () => {
-		assert.equal(shouldMirrorQuery("invoi", "inv", ""), false);
+		assert.equal(
+			shouldMirrorQuery({
+				...onTheBrief,
+				searchInput: "invoi",
+				committedQuery: "inv",
+			}),
+			false,
+		);
+	});
+
+	// The list the reader is leaving is still mounted, and its debounce can settle
+	// under the address of the list they are going to. Writing then navigates back
+	// to this list and replaces the entry they just pushed: they click Inbox and
+	// land on the brief carrying the half-typed query.
+	it("does not write from the list the reader has just left", () => {
+		assert.equal(
+			shouldMirrorQuery({ ...onTheBrief, pathname: "/mail/9f1c-abc" }),
+			false,
+		);
+		assert.equal(
+			shouldMirrorQuery({
+				...onTheBrief,
+				pathname: "/mail/flagged",
+			}),
+			false,
+		);
+		assert.equal(
+			shouldMirrorQuery({ ...onTheBrief, pathname: "/settings/accounts" }),
+			false,
+		);
+	});
+
+	it("writes from a mailbox only while that mailbox is the one addressed", () => {
+		const onInbox = {
+			...onTheBrief,
+			pathname: "/mail/inbox-1",
+			listPath: "/mail/inbox-1",
+		};
+		assert.equal(shouldMirrorQuery(onInbox), true);
+		assert.equal(
+			shouldMirrorQuery({ ...onInbox, pathname: "/mail/archive-1" }),
+			false,
+		);
+	});
+
+	it("still writes with a thread open below the list", () => {
+		// A thread is the list's own child route, so the reader has not left.
+		assert.equal(
+			shouldMirrorQuery({
+				...onTheBrief,
+				pathname: "/mail/brief/thread-1/message-1",
+			}),
+			true,
+		);
 	});
 });
 
@@ -119,24 +174,42 @@ describe("shouldMirrorQuery", () => {
  */
 interface Shell {
 	viewKey: string;
+	/** The path of the list whose mirror is running. */
+	listPath: string;
 	field: string;
 	debounced: string;
 	url: string;
 }
 
 /** One render of the shell for a location, returning the state it settles on. */
-const render = (shell: Shell, viewKey: string, url: string): Shell => {
+const render = (
+	shell: Shell,
+	viewKey: string,
+	url: string,
+	listPath = shell.listPath,
+): Shell => {
 	const field =
 		viewKey === shell.viewKey
 			? shell.field
 			: (searchInputForView(shell.viewKey, viewKey, url) ?? shell.field);
-	return { ...shell, viewKey, field, url };
+	return { ...shell, viewKey, listPath, field, url };
 };
 
-/** What the mirror effect would do after that render. */
-const mirror = (shell: Shell): Shell => {
+/**
+ * What the mirror effect would do after that render. `pathname` is where the
+ * router says the reader is, which is the destination from the moment they
+ * navigate — before the list they are leaving has stopped running effects.
+ */
+const mirror = (shell: Shell, pathname = shell.listPath): Shell => {
 	const committed = committedSearchQuery(shell.field, shell.debounced);
-	if (!shouldMirrorQuery(shell.field, committed, shell.url)) return shell;
+	const mayWrite = shouldMirrorQuery({
+		searchInput: shell.field,
+		committedQuery: committed,
+		urlQuery: shell.url,
+		pathname,
+		listPath: shell.listPath,
+	});
+	if (!mayWrite) return shell;
 	return { ...shell, url: committed };
 };
 
@@ -149,6 +222,7 @@ const settle = (shell: Shell): Shell => ({ ...shell, debounced: shell.field });
 describe("search across a view change", () => {
 	const searching: Shell = {
 		viewKey: mailViewKey(matches("/mail/$mailboxId", "inbox-1")),
+		listPath: "/mail/inbox-1",
 		field: "invoice",
 		debounced: "invoice",
 		url: "invoice",
@@ -157,12 +231,36 @@ describe("search across a view change", () => {
 	it("ends the search when the user leaves the view", () => {
 		// The nav link drops `q`, so the destination carries none.
 		const next = mirror(
-			render(searching, mailViewKey(matches("/mail/$mailboxId", "sent-1")), ""),
+			render(
+				searching,
+				mailViewKey(matches("/mail/$mailboxId", "sent-1")),
+				"",
+				"/mail/sent-1",
+			),
 		);
 		assert.equal(next.field, "");
 		assert.equal(next.url, "");
 	});
 
+	// The whole failure: the reader types on the brief and clicks Inbox inside the
+	// debounce. The brief is still mounted, its debounce settles, and its mirror
+	// would navigate to the brief — superseding the load and replacing the entry
+	// the reader had just pushed, so Inbox never arrives.
+	it("does not navigate back to the list the reader is leaving", () => {
+		const brief: Shell = {
+			viewKey: mailViewKey(matches(MAIL_BRIEF_ROUTE_ID)),
+			listPath: MAIL_BRIEF_ROUTE_ID,
+			field: "inv",
+			debounced: "",
+			url: "",
+		};
+		// The debounce catches up while the inbox is still loading.
+		const leaving = settle(brief);
+		assert.equal(mirror(leaving, "/mail/9f1c-abc").url, "");
+		// On the brief itself the same settled query is written as before.
+		assert.equal(mirror(leaving).url, "inv");
+	});
+
 	it("does not put the query it just left onto the view it landed on", () => {
 		// The debounce still holds "invoice" for up to 200ms after the move. The
 		// mirror must not write it back — that is #47 returning by another route.
@@ -170,6 +268,7 @@ describe("search across a view change", () => {
 			searching,
 			mailViewKey(matches("/mail/$mailboxId", "sent-1")),
 			"",
+			"/mail/sent-1",
 		);
 		assert.equal(landed.debounced, "invoice");
 		assert.equal(mirror(landed).url, "");
@@ -179,7 +278,12 @@ describe("search across a view change", () => {
 		// Dropping the scope chip navigates to the brief carrying the query, so
 		// the same words are searched with a wider scope.
 		const next = mirror(
-			render(searching, mailViewKey(matches("/mail/")), "invoice"),
+			render(
+				searching,
+				mailViewKey(matches(MAIL_BRIEF_ROUTE_ID)),
+				"invoice",
+				MAIL_BRIEF_ROUTE_ID,
+			),
 		);
 		assert.equal(next.field, "invoice");
 		assert.equal(next.url, "invoice");