@remit/web-client 0.0.22 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "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

@@ -47,6 +47,7 @@ import {
 	groupBriefSections,
 	matchesBriefSearch,
 	matchesSearchTokens,
+	mergeSearchRows,
 	toThreadRowData,
 } from "@/lib/brief";
 import { isServerError } from "@/lib/error-classifier";
@@ -57,6 +58,10 @@ import { MailListHeader } from "./MailListHeader";
 
 /* The brief's attribute chips as predicates (mirrors the kit `briefFilterChips`
    ids) so the phone search takeover narrows results the same way the list does. */
+/* Page size for the unscoped cross-folder search. One page is what the takeover
+   and the "Top matches" list render; the server caps it at 500. */
+const UNSCOPED_SEARCH_PAGE_SIZE = 200;
+
 const BRIEF_SEARCH_PREDICATES: Record<string, (t: ThreadRowData) => boolean> = {
 	unread: (t) => !t.isRead,
 	attachment: (t) => t.hasAttachment === true,
@@ -264,6 +269,21 @@ export function DailyBrief({
 		tokenContext,
 	);
 
+	// --- Unscoped search query ---
+	// The brief's list is the unified INBOX, so filtering it client-side can only
+	// ever find inbox mail. The same endpoint in search mode (`query`) widens to
+	// every non-muted folder of every account — Archive, Sent, Spam, custom
+	// folders — and matches subject/From in the query. Its rows are merged with
+	// the client-side pass below, which still contributes snippet matches the
+	// server does not index.
+	const { data: searchData, isFetching: searchFetching } = useQuery({
+		...unifiedThreadOperationsListAllThreadsOptions({
+			query: { query: sq, limit: UNSCOPED_SEARCH_PAGE_SIZE },
+		}),
+		enabled: sq.length > 0,
+		staleTime: 30_000,
+	});
+
 	// Convert API rows to ThreadRowData, narrowing only by the selected account
 	// and the free-text search plus any filter tokens (`from:`, `has:attachment`,
 	// `is:unread`, `before:`/`after:`, `in:`, `account:`) parsed out of the
@@ -271,20 +291,20 @@ export function DailyBrief({
 	// `BriefSections` filter row's job, so the full per-category sections are
 	// handed to it; it groups, narrows, and flattens.
 	const filteredRows = useMemo<ThreadRowData[]>(() => {
-		const raw = threadsData?.items ?? [];
-		return raw
-			.filter(
-				(t) =>
-					selectedAccountId === "all" ||
-					(t.accountId ?? t.accountConfigId) === selectedAccountId,
-			)
-			.map(toThreadRowData)
-			.filter(
-				(t) =>
-					(!sq || matchesBriefSearch(t, sq)) &&
-					matchesSearchTokens(t, queryTokens),
-			);
-	}, [threadsData, selectedAccountId, sq, queryTokens]);
+		const briefRows = (threadsData?.items ?? []).map(toThreadRowData);
+		// No free text: the brief list as it comes, order untouched.
+		const rows = sq
+			? mergeSearchRows(
+					briefRows.filter((t) => matchesBriefSearch(t, sq)),
+					(searchData?.items ?? []).map(toThreadRowData),
+				)
+			: briefRows;
+		return rows.filter(
+			(t) =>
+				(selectedAccountId === "all" || t.accountId === selectedAccountId) &&
+				matchesSearchTokens(t, queryTokens),
+		);
+	}, [threadsData, searchData, selectedAccountId, sq, queryTokens]);
 
 	const sections = useMemo<ThreadSection[]>(
 		() => groupBriefSections(filteredRows),
@@ -433,7 +453,7 @@ export function DailyBrief({
 			footer={isDesktop ? <KeyboardHintBar /> : undefined}
 			searchFilter={searchFilterConfig}
 			searchResults={searchResults}
-			searchLoading={isLoading}
+			searchLoading={isLoading || searchFetching}
 			relatedResults={relatedResults}
 			relatedLoading={relatedLoading}
 			onSelectSearchResult={onSelectSearchResult}

package/src/components/mail/MailboxPane.tsx

@@ -947,14 +947,13 @@ function MailboxList() {
 		() => threads.map(threadToSearchResult),
 		[threads],
 	);
-	// The route scopes this view, and the top bar's chip says so. Both sections
-	// are named by the ground they cover so that scope is never overstated: the
-	// literal engine searches this mailbox and nothing else (there is no
-	// cross-mailbox thread search), while the semantic engine runs unscoped and
-	// its section says "Everywhere" (#47). Reaching past the folder is a labelled
-	// section, not a silent widening of the chip. Results are deduped by thread,
-	// so a thread never shows in both.
+	// The route scopes this view and the top bar's chip says so, so every engine
+	// here respects it: the literal engine searches this mailbox, and the
+	// semantic engine takes the same `mailboxId`. No chip means global; a chip
+	// means nothing on the route reaches past it. Results are deduped by thread,
+	// so a thread never shows in both sections.
 	const { hits: semanticHits, isLoading: relatedLoading } = useSemanticSearch({
+		mailboxId,
 		filterCategory,
 	});
 	const relatedResults = useMemo(
@@ -969,9 +968,9 @@ function MailboxList() {
 		(result: SearchResult) =>
 			navigate({
 				to: "/mail/$mailboxId",
-				// A hit from the unscoped "Everywhere" section lives in another
-				// mailbox; open it there, so the list, the toolbar's verbs and the
-				// message all belong to the same mailbox.
+				// Both sections are scoped to this mailbox, so a result's own
+				// mailbox is normally this one; keep reading it off the result so a
+				// row can never open under a mailbox it does not belong to.
 				params: { mailboxId: result.mailboxId ?? mailboxId },
 				search: (prev: Record<string, unknown>) => ({
 					...prev,
@@ -1066,8 +1065,6 @@ function MailboxList() {
 			relatedResults={relatedResults}
 			relatedLoading={relatedLoading}
 			onSelectSearchResult={handleSelectSearchResult}
-			searchResultsLabel={`In ${listTitle}`}
-			relatedResultsLabel="Everywhere"
 		>
 			{body}
 		</MailViewChrome>

package/src/hooks/useSemanticSearch.ts

@@ -2,8 +2,10 @@ import { semanticSearchOperationsSemanticSearchOptions } from "@remit/api-http-c
 import type { RemitImapSemanticSearchResult } from "@remit/api-http-client/types.gen.ts";
 import { MessageCategory } from "@remit/domain-enums";
 import { useQuery } from "@tanstack/react-query";
+import { useRouterState } from "@tanstack/react-router";
 import { useMailContext } from "@/lib/mail-context";
 import { normalizeSearchQuery } from "@/lib/search-query";
+import { semanticMailboxScope } from "@/lib/search-scope";
 import { parseSearchTokens } from "@/lib/search-tokens";
 import { useSearchTokenContext } from "./useSearchTokenContext";
 
@@ -22,8 +24,9 @@ const toCategoryParam = (
 
 interface UseSemanticSearchParams {
 	/**
-	 * Restrict results to a single mailbox (the scoped inbox). Omit for the
-	 * cross-account daily brief, where semantic search spans every account.
+	 * Restrict results to a single mailbox. A mailbox route pins the scope to its
+	 * own mailbox regardless of what is passed here, so this only carries a scope
+	 * a route does not already imply.
 	 */
 	mailboxId?: string;
 	/**
@@ -35,9 +38,10 @@ interface UseSemanticSearchParams {
 
 /**
  * Fetch semantic-search hits for the active query (one source of truth: the
- * debounced `searchQuery` in `MailContext`). Scoping mirrors the literal search:
- * pass `mailboxId` for a scoped inbox, omit it for the global brief. Disabled
- * until the query is non-empty so an empty field issues no request.
+ * debounced `searchQuery` in `MailContext`). Scoping mirrors the literal search
+ * and is taken from the route (`semanticMailboxScope`): no chip means global, a
+ * chip means this engine respects it like every other. Disabled until the query
+ * is non-empty so an empty field issues no request.
  *
  * Filter tokens (`has:attachment`, `is:unread`, `before:`/`after:`) parsed from
  * the query map onto the search API's own filter params. `from:` and
@@ -50,7 +54,7 @@ interface UseSemanticSearchParams {
  * `useSearchTokenContext` does not resolve the term there at all — the term
  * stays free text and no engine, and no chip, treats it as a filter.
  *
- * Without a `mailboxId` the request spans every mailbox of every account the
+ * With no resolved mailbox the request spans every mailbox of every account the
  * caller owns: the backend partitions the vector index by accountConfigId (one
  * per signed-in user, not per mail account), so unscoped is genuinely global.
  */
@@ -63,9 +67,15 @@ export function useSemanticSearch({
 } {
 	const { searchQuery } = useMailContext();
 	const tokenContext = useSearchTokenContext();
+	const matches = useRouterState({ select: (s) => s.matches });
 	const normalizedQuery = normalizeSearchQuery(searchQuery);
 	const { freeText, tokens } = parseSearchTokens(normalizedQuery, tokenContext);
-	const enabled = normalizedQuery.length > 0;
+	// `freeText`, not the raw query: a query of nothing but tokens
+	// (`has:attachment`, `in:archive`) parses to empty free text, and asking a
+	// vector index what an empty string means has no answer to give. The literal
+	// engines still apply those tokens; the semantic section simply has nothing
+	// to rank.
+	const enabled = freeText.length > 0;
 
 	const category = toCategoryParam(filterCategory);
 	const hasAttachment = tokens.some((t) => t.type === "hasAttachment")
@@ -75,7 +85,12 @@ export function useSemanticSearch({
 	const afterToken = tokens.find((t) => t.type === "after");
 	const beforeToken = tokens.find((t) => t.type === "before");
 	const inToken = tokens.find((t) => t.type === "in");
-	const effectiveMailboxId = mailboxId ?? inToken?.mailboxId;
+	// The route decides the scope, not the call site — see `semanticMailboxScope`.
+	const effectiveMailboxId = semanticMailboxScope({
+		matches,
+		callerMailboxId: mailboxId,
+		inTokenMailboxId: inToken?.mailboxId,
+	});
 
 	const { data, isLoading } = useQuery({
 		...semanticSearchOperationsSemanticSearchOptions({

package/src/lib/brief.test.ts

@@ -6,6 +6,7 @@ import {
 	groupBriefSections,
 	matchesBriefSearch,
 	matchesSearchTokens,
+	mergeSearchRows,
 	toThreadRowData,
 } from "./brief.js";
 import type { SearchToken } from "./search-tokens.js";
@@ -433,3 +434,81 @@ describe("matchesSearchTokens", () => {
 		);
 	});
 });
+
+// #49: the brief's list is the unified INBOX, so filtering it client-side found
+// only inbox mail. The server's cross-folder search supplies the rest, and the
+// two are merged.
+describe("mergeSearchRows", () => {
+	test("keeps rows the server found in other folders", () => {
+		const merged = mergeSearchRows(
+			[row({ id: "inbox-hit", sentDate: 300 })],
+			[
+				row({ id: "archive-hit", sentDate: 200 }),
+				row({ id: "spam-hit", sentDate: 100 }),
+			],
+		);
+
+		assert.deepEqual(
+			merged.map((r) => r.id),
+			["inbox-hit", "archive-hit", "spam-hit"],
+		);
+	});
+
+	test("keeps a snippet-only match the server cannot see", () => {
+		const merged = mergeSearchRows(
+			[row({ id: "snippet-only", sentDate: 100 })],
+			[],
+		);
+
+		assert.deepEqual(
+			merged.map((r) => r.id),
+			["snippet-only"],
+		);
+	});
+
+	test("the two sources overlap on INBOX, so rows are deduped", () => {
+		const merged = mergeSearchRows(
+			[row({ id: "shared", sentDate: 200, subject: "from the brief" })],
+			[
+				row({ id: "shared", sentDate: 200, subject: "from the search" }),
+				row({ id: "archive-hit", sentDate: 100 }),
+			],
+		);
+
+		assert.deepEqual(
+			merged.map((r) => r.id),
+			["shared", "archive-hit"],
+		);
+		assert.equal(merged[0].subject, "from the brief");
+	});
+
+	test("the union reads newest first, interleaving both sources", () => {
+		const merged = mergeSearchRows(
+			[
+				row({ id: "brief-new", sentDate: 400 }),
+				row({ id: "brief-old", sentDate: 200 }),
+			],
+			[
+				row({ id: "search-mid", sentDate: 300 }),
+				row({ id: "search-oldest", sentDate: 100 }),
+			],
+		);
+
+		assert.deepEqual(
+			merged.map((r) => r.id),
+			["brief-new", "search-mid", "brief-old", "search-oldest"],
+		);
+	});
+
+	test("a row without a sentDate sorts last", () => {
+		const merged = mergeSearchRows(
+			[row({ id: "undated" })],
+			[row({ id: "dated", sentDate: 100 })],
+		);
+
+		assert.deepEqual(
+			merged.map((r) => r.id),
+			["dated", "undated"],
+		);
+	});
+});

package/src/lib/brief.ts

@@ -67,6 +67,33 @@ export function toThreadRowData(
 	};
 }
 
+/**
+ * Union of the brief's own rows with the rows the server's cross-folder search
+ * returned, newest first.
+ *
+ * Both lists are needed. The server matches subject and From only, so a row
+ * whose snippet carries the term is found only by the client-side pass over the
+ * loaded brief rows; the server pass is the only one that reaches Archive,
+ * Sent, Spam and custom folders, which the brief list never loads. The two
+ * overlap on INBOX, so rows are deduped by id, the first occurrence winning.
+ *
+ * Rows without a `sentDate` sort last; the brief's own list is already newest
+ * first, so this only has to re-interleave the two sources.
+ */
+export function mergeSearchRows(
+	briefRows: ThreadRowData[],
+	searchRows: ThreadRowData[],
+): ThreadRowData[] {
+	const seen = new Set<string>();
+	const merged: ThreadRowData[] = [];
+	for (const row of [...briefRows, ...searchRows]) {
+		if (seen.has(row.id)) continue;
+		seen.add(row.id);
+		merged.push(row);
+	}
+	return merged.sort((a, b) => (b.sentDate ?? 0) - (a.sentDate ?? 0));
+}
+
 /**
  * Category sections in fixed display order. The `id`/`label` drive the rendered
  * section; `category` is the row category that routes into it.

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

@@ -11,6 +11,7 @@ import {
 	SEARCH_SCOPE_CHIP_ID,
 	scopeLabelForMailboxName,
 	searchScopeForRoute,
+	semanticMailboxScope,
 } from "./search-scope";
 
 const matches = (routeId: string) => [{ routeId: "/mail" }, { routeId }];
@@ -102,3 +103,95 @@ describe("scopeLabelForMailboxName", () => {
 		assert.equal(scopeLabelForMailboxName("Work  Stuff"), 'in:"work stuff"');
 	});
 });
+
+// The invariant: no chip means global, a chip means every engine on that route
+// respects it. The semantic engine used to run unscoped inside a mailbox under
+// an "Everywhere" heading, contradicting the `in:` chip the same bar showed.
+describe("semanticMailboxScope — a chip binds every engine on the route", () => {
+	const mailbox = (mailboxId: string) => [
+		{ routeId: "/mail" },
+		{ routeId: MAIL_MAILBOX_ROUTE_ID, params: { mailboxId } },
+	];
+
+	it("pins a mailbox route to its own mailbox", () => {
+		assert.equal(
+			semanticMailboxScope({ matches: mailbox("mbx-spam") }),
+			"mbx-spam",
+		);
+	});
+
+	it("a mailbox route ignores a caller asking for somewhere else", () => {
+		assert.equal(
+			semanticMailboxScope({
+				matches: mailbox("mbx-spam"),
+				callerMailboxId: "mbx-archive",
+			}),
+			"mbx-spam",
+		);
+	});
+
+	it("a mailbox route ignores a typed in: term", () => {
+		assert.equal(
+			semanticMailboxScope({
+				matches: mailbox("mbx-spam"),
+				inTokenMailboxId: "mbx-archive",
+			}),
+			"mbx-spam",
+		);
+	});
+
+	it("a mailbox route never widens to global", () => {
+		const scope = semanticMailboxScope({ matches: mailbox("mbx-spam") });
+		assert.notEqual(scope, undefined, "a scoped route must carry a scope");
+	});
+
+	// Flagged and outbox are scoped to a collection, which the mailbox-scoped
+	// semantic API cannot express — so neither runs a semantic section, and
+	// neither may fall back to a typed `in:` under its own chip.
+	for (const routeId of [MAIL_FLAGGED_ROUTE_ID, MAIL_OUTBOX_ROUTE_ID]) {
+		it(`${routeId} never honours a typed in: term`, () => {
+			assert.equal(
+				semanticMailboxScope({
+					matches: matches(routeId),
+					inTokenMailboxId: "mbx-archive",
+				}),
+				undefined,
+			);
+		});
+	}
+
+	it("the daily brief is global — no route scope, no chip", () => {
+		assert.equal(
+			semanticMailboxScope({ matches: matches(MAIL_BRIEF_ROUTE_ID) }),
+			undefined,
+		);
+	});
+
+	it("the daily brief is the one route a typed in: narrows", () => {
+		assert.equal(
+			semanticMailboxScope({
+				matches: matches(MAIL_BRIEF_ROUTE_ID),
+				inTokenMailboxId: "mbx-archive",
+			}),
+			"mbx-archive",
+		);
+	});
+
+	it("every scoped route resolves a scope or refuses to widen", () => {
+		// Pins the invariant across the route table rather than one case at a
+		// time: on a scoped route the resolved scope is either the route's own
+		// mailbox, or nothing that came from the typed query.
+		const scoped = [
+			{ matches: mailbox("mbx-spam"), expected: "mbx-spam" },
+			{ matches: matches(MAIL_FLAGGED_ROUTE_ID), expected: undefined },
+			{ matches: matches(MAIL_OUTBOX_ROUTE_ID), expected: undefined },
+		];
+		for (const { matches: m, expected } of scoped) {
+			assert.equal(isScopedRoute(m), true);
+			assert.equal(
+				semanticMailboxScope({ matches: m, inTokenMailboxId: "mbx-elsewhere" }),
+				expected,
+			);
+		}
+	});
+});

package/src/lib/search-scope.ts

@@ -26,6 +26,7 @@ import {
 	isFlaggedRoute,
 	isMailboxRoute,
 	isOutboxRoute,
+	MAIL_MAILBOX_ROUTE_ID,
 	type MailRouteMatch,
 } from "./mail-route";
 
@@ -75,6 +76,45 @@ export function isScopedRoute(matches: readonly MailRouteMatch[]): boolean {
 	);
 }
 
+/**
+ * The mailbox id carried by a mailbox route, or `undefined` on any other route.
+ */
+export function routeMailboxId(
+	matches: readonly MailRouteMatch[],
+): string | undefined {
+	return matches.find((m) => m.routeId === MAIL_MAILBOX_ROUTE_ID)?.params
+		?.mailboxId;
+}
+
+/**
+ * The mailbox every engine on the active route must be pinned to.
+ *
+ * No chip means global; a chip means nothing on the route reaches past it. The
+ * semantic engine used to run unscoped inside a mailbox under an "Everywhere"
+ * heading, which contradicted the `in:` chip the same bar was showing, so the
+ * scope is now resolved from the route here rather than left to each caller:
+ *
+ *  - A mailbox route pins to its own mailbox. It beats both the caller's
+ *    argument and a typed `in:`, so no call site can widen or redirect it.
+ *  - Any other scoped route (flagged, outbox) never falls back to a typed
+ *    `in:`. Its scope is a collection rather than a folder, which the semantic
+ *    API cannot express — which is why neither view runs a semantic section
+ *    today. Honouring `in:` there would be a search reaching past a chip that
+ *    promises otherwise.
+ *  - An unscoped route (the daily brief) is global unless a typed `in:` narrows
+ *    it, which is the one place `useSearchTokenContext` resolves that term.
+ */
+export function semanticMailboxScope(args: {
+	matches: readonly MailRouteMatch[];
+	callerMailboxId?: string;
+	inTokenMailboxId?: string;
+}): string | undefined {
+	const fromRoute = routeMailboxId(args.matches);
+	if (fromRoute) return fromRoute;
+	if (isScopedRoute(args.matches)) return args.callerMailboxId;
+	return args.callerMailboxId ?? args.inTokenMailboxId;
+}
+
 /**
  * The scope of the active route.
  *