@remit/web-client 0.0.278 → 0.0.280

package/src/lib/brief.test.ts

@@ -11,11 +11,7 @@ import {
 	BRIEF_CATEGORIES,
 	type BriefCategoryResult,
 	briefSections,
-	briefSectionTotal,
-	excludeMutedSenders,
-	matchesBriefSearch,
 	matchesSearchTokens,
-	mergeSearchRows,
 	toThreadRowData,
 } from "./brief.js";
 import type { SearchToken } from "./search-tokens.js";
@@ -288,157 +284,6 @@ describe("briefSections", () => {
 	});
 });
 
-// issue #301: `Address.flags.muted` is denormalized onto each row as
-// `muted`; the brief excludes those rows before grouping into sections.
-describe("excludeMutedSenders", () => {
-	test("drops a row whose sender is muted", () => {
-		const kept = threadResponse({ threadMessageId: "keep" });
-		const muted = threadResponse({ threadMessageId: "mute-me", muted: true });
-		const result = excludeMutedSenders([kept, muted]);
-		assert.deepStrictEqual(
-			result.map((t) => t.threadMessageId),
-			["keep"],
-		);
-	});
-
-	test("keeps rows whose sender is not muted", () => {
-		const rows = [
-			threadResponse({ threadMessageId: "a", muted: false }),
-			threadResponse({ threadMessageId: "b" }),
-		];
-		assert.strictEqual(excludeMutedSenders(rows).length, 2);
-	});
-
-	test("returns an empty array when every sender is muted", () => {
-		const rows = [
-			threadResponse({ threadMessageId: "a", muted: true }),
-			threadResponse({ threadMessageId: "b", muted: true }),
-		];
-		assert.deepStrictEqual(excludeMutedSenders(rows), []);
-	});
-
-	test("a muted sender's message is excluded from every section, not folded into uncategorized", () => {
-		const rows = [
-			threadResponse({
-				threadMessageId: "muted-personal",
-				messageId: "muted-personal",
-				category: "personal",
-				muted: true,
-			}),
-			threadResponse({
-				threadMessageId: "kept-personal",
-				messageId: "kept-personal",
-				category: "personal",
-			}),
-		];
-		const kept = excludeMutedSenders(rows).map(toThreadRowData);
-		const sections = briefSections([
-			{
-				category: "personal",
-				rows: kept,
-				total: { kind: "exact", value: kept.length },
-				atCap: false,
-				loading: false,
-				failed: false,
-			},
-		]);
-		const allIds = sections.flatMap((s) => s.threads.map((t) => t.id));
-		assert.deepStrictEqual(allIds, ["kept-personal"]);
-	});
-
-	test("muting every candidate row leaves no sections (brief empty state)", () => {
-		const rows = [
-			threadResponse({
-				threadMessageId: "a",
-				messageId: "a",
-				category: "personal",
-				muted: true,
-			}),
-			threadResponse({
-				threadMessageId: "b",
-				messageId: "b",
-				category: "newsletter",
-				muted: true,
-			}),
-		];
-		const kept = excludeMutedSenders(rows).map(toThreadRowData);
-		const sections = briefSections([
-			{
-				category: "personal",
-				rows: kept,
-				total: { kind: "exact", value: 0 },
-				atCap: false,
-				loading: false,
-				failed: false,
-			},
-		]);
-		assert.deepStrictEqual(sections, []);
-	});
-});
-
-// The count is the server's, taken over a scope that includes senders the reader
-// muted — `listAllThreads` has no `muted` parameter. The list drops their mail,
-// so the number would overstate what is on screen.
-describe("briefSectionTotal", () => {
-	const counted: ResultCount = { kind: "exact", value: 4753 };
-
-	test("keeps the count when no sender in the rows is muted", () => {
-		assert.deepStrictEqual(
-			briefSectionTotal(counted, [
-				threadResponse({ threadMessageId: "a" }),
-				threadResponse({ threadMessageId: "b", muted: false }),
-			]),
-			counted,
-		);
-	});
-
-	test("withholds the count when the rows show a muted sender", () => {
-		assert.deepStrictEqual(
-			briefSectionTotal(counted, [
-				threadResponse({ threadMessageId: "a" }),
-				threadResponse({ threadMessageId: "b", muted: true }),
-			]),
-			{ kind: "unknown" },
-		);
-	});
-
-	test("a count nobody took stays absent", () => {
-		assert.deepStrictEqual(briefSectionTotal({ kind: "unknown" }, []), {
-			kind: "unknown",
-		});
-	});
-});
-
-describe("matchesBriefSearch", () => {
-	const r = row({
-		id: "1",
-		fromName: "Alice Tan",
-		fromEmail: "alice@example.com",
-		subject: "Q3 roadmap",
-		snippet: "See the attached deck",
-	});
-
-	test("matches on fromName (case-insensitive)", () => {
-		assert.strictEqual(matchesBriefSearch(r, "alice"), true);
-	});
-
-	test("matches on fromEmail", () => {
-		assert.strictEqual(matchesBriefSearch(r, "alice@example"), true);
-	});
-
-	test("matches on subject", () => {
-		assert.strictEqual(matchesBriefSearch(r, "roadmap"), true);
-	});
-
-	test("matches on snippet", () => {
-		assert.strictEqual(matchesBriefSearch(r, "deck"), true);
-	});
-
-	test("returns false when query matches nothing", () => {
-		assert.strictEqual(matchesBriefSearch(r, "zyxwvuts"), false);
-	});
-});
-
 describe("matchesSearchTokens", () => {
 	const from = (value: string): SearchToken => ({
 		type: "from",
@@ -646,82 +491,3 @@ describe("matchesSearchTokens", () => {
 		);
 	});
 });
-
-// #49: a listing complete under its own criteria still cannot see a snippet
-// match, and the server's cross-folder search cannot see one either. The two
-// halves are merged. The brief no longer uses this — its sections are pages, and
-// merging a page with a search window orders two truncated lists (#312).
-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

@@ -28,11 +28,11 @@
  * a high-volume mailbox read≠handled and unread≠important; unread is a
  * user-selectable filter chip instead.
  *
- * Muted senders and categories the scope holds none of are excluded. Mute
- * filtering happens in `excludeMutedSenders`, applied by the caller to the raw
- * thread rows before `toThreadRowData` — the server denormalizes `muted` onto
- * each row from the From address's flags (RFC 039 Decision 3, issue #301), so no
- * client-side Address lookup is needed.
+ * Muted senders and categories the scope holds none of are excluded. Mute is
+ * `muted=false` on each section's request, so the rows and the count answer the
+ * same predicate — dropping muted rows here instead left a header stating a
+ * number larger than the list under it, and a "Show all" that opened mail the
+ * brief would not render (#1137).
  */
 
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
@@ -80,71 +80,6 @@ export function toThreadRowData(
 	};
 }
 
-/**
- * Excludes rows whose From address is muted (`thread.muted === true`,
- * denormalized server-side from `Address.flags.muted`). Muting hides a
- * sender from the brief only — it never deletes, marks read, or moves their
- * mail, so callers outside the brief (mailbox listings, search) must not
- * apply this filter.
- */
-/**
- * The section's count, or no number, once mute is taken into account.
- *
- * Mute is the one criterion the request cannot be asked about: `listAllThreads`
- * has no `muted` parameter, so a scope holding a muted sender is counted with
- * that sender's mail in it while the list renders without it. The header would
- * overstate, and "Show all" would offer rows the brief will not show.
- *
- * Withheld per section rather than for the whole brief — one muted marketer must
- * not take the number off Personal — and only where a mute is visible in the
- * rows on hand. A muted sender below a section's page is not visible, so this
- * suppresses a number known to be wrong rather than certifying the rest.
- */
-export function briefSectionTotal(
-	total: ResultCount,
-	rows: RemitImapThreadMessageResponse[],
-): ResultCount {
-	return rows.some((row) => row.muted === true) ? { kind: "unknown" } : total;
-}
-
-export function excludeMutedSenders(
-	threads: RemitImapThreadMessageResponse[],
-): RemitImapThreadMessageResponse[] {
-	return threads.filter((t) => t.muted !== true);
-}
-
-/**
- * Union of a complete server-filtered listing with the rows the server's
- * cross-folder text search returned, newest first.
- *
- * Both lists are needed where the listing itself is complete under its criteria
- * — the Flagged collection is, and pages to its end. The server matches subject
- * and From only, so a row whose snippet carries the term is found only by the
- * client-side pass; the server pass is the only one that reaches Archive, Sent,
- * Spam and custom folders. The two overlap, so rows are deduped by id, the first
- * occurrence winning.
- *
- * Not for a paginated prefix. The brief's sections are per-category pages, so
- * merging one with a search window and re-sorting would order two truncated
- * lists against each other and call the result newest-first (#312).
- *
- * 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));
-}
-
 /**
  * The categories the brief asks for, in the order it renders them. A category
  * is both the section's own scope and the query parameter its request carries;
@@ -210,19 +145,6 @@ export function briefSections(
 	return sections;
 }
 
-/**
- * Returns true when `t` matches the free-text `query` (lower-cased).
- * Checked against fromName, fromEmail, subject, and snippet.
- */
-export function matchesBriefSearch(t: ThreadRowData, query: string): boolean {
-	return (
-		t.fromName.toLowerCase().includes(query) ||
-		t.fromEmail.toLowerCase().includes(query) ||
-		t.subject.toLowerCase().includes(query) ||
-		t.snippet.toLowerCase().includes(query)
-	);
-}
-
 /**
  * Returns true when `t` satisfies every token handed to it.
  *
@@ -234,10 +156,12 @@ export function matchesBriefSearch(t: ThreadRowData, query: string): boolean {
  * the rows fetched so far" (#312).
  *
  * Every token is implemented so that a request carrying fewer parameters still
- * has somewhere to put the rest: `listAllThreads` has no `from` or `subject` of
- * its own, and no endpoint has `before:`, `after:`, `in:` or `account:`. A row
- * without the data a token needs (no `sentDate` for `before:`/`after:`) never
- * matches it, so it drops out rather than showing under an unverifiable filter.
+ * has somewhere to put the rest: no endpoint has `before:`, `after:`, `in:` or
+ * `account:` in the set these tokens are split against, and each takes one
+ * `from` and one `subject`, so a second of either — or one a chip overruled —
+ * lands here. A row without the data a token needs (no `sentDate` for
+ * `before:`/`after:`) never matches it, so it drops out rather than showing
+ * under an unverifiable filter.
  */
 export function matchesSearchTokens(
 	t: ThreadRowData,

package/src/lib/flagged-criteria.test.ts

@@ -71,16 +71,31 @@ describe("flaggedCriteria", () => {
 		assert.deepEqual(residualTypes("is:starred"), []);
 	});
 
-	// No `from`/`subject` parameter on this endpoint: its one text parameter
-	// matches both at once, so these stay a pass over the returned rows rather
-	// than being dropped from a request that never carried them.
+	// #1128: the free-text parameter matches subject and From at once, so
+	// neither token could be asked for on its own. Both applied over the pages
+	// already fetched, and a starred collection is paged — a match below them
+	// never appeared. Each has its own parameter now.
+	test("from: and subject: travel as parameters", () => {
+		assert.deepEqual(criteriaOf("from:alice"), { from: "alice" });
+		assert.deepEqual(residualTypes("from:alice"), []);
+		assert.deepEqual(criteriaOf("subject:invoice"), { subject: "invoice" });
+		assert.deepEqual(residualTypes("subject:invoice"), []);
+	});
+
 	test("keeps the tokens no parameter carries", () => {
-		assert.deepEqual(residualTypes("from:alice"), ["from"]);
 		assert.deepEqual(residualTypes("before:2026-01-01"), ["before"]);
 		assert.deepEqual(residualTypes("in:sent"), ["in"]);
 		assert.deepEqual(residualTypes("account:alice"), ["account"]);
 	});
 
+	// One parameter per field, so only the first value can be expressed.
+	test("a second subject: stays residue", () => {
+		assert.deepEqual(criteriaOf("subject:one subject:two"), {
+			subject: "one",
+		});
+		assert.deepEqual(residualTypes("subject:one subject:two"), ["subject"]);
+	});
+
 	test("the chip wins over a token that contradicts it", () => {
 		const { criteria, residual } = flaggedCriteria(
 			chips("all", ["unread"]),

package/src/lib/flagged-criteria.ts

@@ -2,12 +2,12 @@
  * What the Flagged view asks `listAllThreads` for, and what is left over.
  *
  * Every criterion the view offers — the category chip, the Unread and Has
- * attachment chips, and the `category:` / `is:unread` / `is:read` /
- * `has:attachment` / `is:starred` tokens typed in the field — is a column on
- * the ThreadMessage row, so all of them travel as query parameters. A criterion
- * applied over the pages loaded so far is the defect this replaces: a starred
- * collection is paged, so anything below the newest page was invisible to it
- * (#308).
+ * attachment chips, and the `from:` / `subject:` / `category:` / `is:unread` /
+ * `is:read` / `has:attachment` / `is:starred` tokens typed in the field — is a
+ * field on the ThreadMessage row, so all of them travel as query parameters. A
+ * criterion applied over the pages loaded so far is the defect this replaces: a
+ * starred collection is paged, so anything below the newest page was invisible
+ * to it (#308, #1128).
  *
  * `starred` is the view rather than a criterion: the request always carries it,
  * which is what makes `is:starred` a carried token instead of residue.
@@ -16,24 +16,25 @@
  * beats text in a field — and the overruled token drops to the residue, where
  * it matches nothing, which is the honest answer to a contradiction.
  */
-import type {
-	InboxFilterCriteria,
-	InboxFilterParams,
-} from "./inbox-filters.js";
+import type { InboxFilterCriteria } from "./inbox-filters.js";
 import { inboxFilterParams } from "./inbox-filters.js";
 import type { SearchToken } from "./search-tokens.js";
 import {
 	type ThreadSearchTokenParamName,
+	type ThreadSearchTokenParams,
 	threadSearchTokens,
 } from "./thread-search-tokens.js";
 
 /**
- * The token parameters `listAllThreads` carries. It has no `from` or `subject`
- * of its own — its one text parameter matches both at once — so those two
- * tokens stay residue rather than being dropped from a request that never had
- * them.
+ * The token parameters `listAllThreads` carries, which is every parameter it
+ * takes. `from` and `subject` joined them once the operation grew a parameter
+ * for each field: its one free-text parameter matches both at once, so neither
+ * token could be asked for on its own and both were applied over the pages
+ * already fetched — a match below them never appeared (#1128).
  */
 export const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
+	"from",
+	"subject",
 	"category",
 	"unread",
 	"starred",
@@ -42,7 +43,7 @@ export const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
 
 export interface FlaggedCriteria {
 	/** What the request narrows by, chips and carried tokens together. */
-	criteria: InboxFilterParams;
+	criteria: ThreadSearchTokenParams;
 	/** The tokens no parameter carries; apply these over the returned rows. */
 	residual: SearchToken[];
 }

package/src/lib/inbox-filters.ts

@@ -89,11 +89,28 @@ export const filterReach = (query: ThreadSearchQuery): FilterReach =>
 		? "loaded-pages"
 		: "whole-folder";
 
+/**
+ * A list request's narrowing parameters, as far as the previous-data guard
+ * reads them. The chips, plus the two scopes a view sets for itself: the
+ * account the pills name, and whether muted senders are in.
+ *
+ * The text parameters are deliberately absent, `from` and `subject` with the
+ * free text: all three are typed in one field, and a query being refined is the
+ * one change that may keep the previous answer on screen while the next is in
+ * flight.
+ */
+export type ListFilterParams = InboxFilterParams & {
+	accountId?: string;
+	muted?: boolean;
+};
+
 const FILTER_PARAM_NAMES = [
 	"category",
 	"unread",
 	"starred",
 	"attachments",
+	"accountId",
+	"muted",
 ] as const;
 
 const filterIdentity = (query: Record<string, unknown> | undefined): string =>
@@ -121,7 +138,7 @@ const queryOf = (queryKey: unknown): Record<string, unknown> | undefined => {
  */
 export const sameInboxFilter = (
 	queryKey: unknown,
-	params: InboxFilterParams,
+	params: ListFilterParams,
 ): boolean => {
 	const previous = queryOf(queryKey);
 	if (!previous) return false;

package/src/lib/organize/sender-fallback.test.ts

@@ -4,7 +4,10 @@ import { buildSenderFallbackDraft } from "./sender-fallback";
 
 describe("buildSenderFallbackDraft", () => {
 	it("combines the sender clauses with Or and carries no anchor", () => {
-		const draft = buildSenderFallbackDraft(["npm@github.com", "a@x.com"]);
+		const draft = buildSenderFallbackDraft(
+			["npm@github.com", "a@x.com"],
+			["Deploy failed", "Standup notes"],
+		);
 		assert.equal(draft.matchOperator, "Or");
 		assert.equal(draft.anchorMessageId, undefined);
 		assert.deepEqual(draft.literalClauses, [
@@ -14,10 +17,36 @@ describe("buildSenderFallbackDraft", () => {
 	});
 
 	it("carries a single FromDomain clause when the senders share a domain", () => {
-		const draft = buildSenderFallbackDraft(["npm@github.com", "ci@github.com"]);
+		const draft = buildSenderFallbackDraft(
+			["npm@github.com", "ci@github.com"],
+			["Deploy failed", "Standup notes"],
+		);
 		assert.equal(draft.matchOperator, "Or");
 		assert.deepEqual(draft.literalClauses, [
 			{ field: "FromDomain", value: "github.com" },
 		]);
 	});
+
+	it("falls back to a shared subject when mixed senders share no domain (#458)", () => {
+		const draft = buildSenderFallbackDraft(
+			["billing@acme.test", "accounts@globex.test"],
+			["Invoice 1841", "Invoice 1902"],
+		);
+		assert.equal(draft.matchOperator, "Or");
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+	});
+
+	it("offers one sender chip each when mixed senders share no subject either", () => {
+		const draft = buildSenderFallbackDraft(
+			["billing@acme.test", "accounts@globex.test"],
+			["Invoice 1841", "Standup notes"],
+		);
+		assert.equal(draft.matchOperator, "Or");
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "From", value: "billing@acme.test" },
+			{ field: "From", value: "accounts@globex.test" },
+		]);
+	});
 });

package/src/lib/organize/sender-fallback.ts

@@ -1,26 +1,30 @@
 import type { RemitImapOrganizeInput } from "@remit/api-http-client/types.gen.ts";
-import { deriveSenderClauses } from "@remit/ui";
+import { derivePropertyClauses } from "@remit/ui";
 import type { OrganizeDraft } from "./organize-model";
 
 /**
  * The widen fallback for a deployment that ships no vector pipeline (self-host
  * sqlite — semantic-capability.ts). The semantic anchor matches nothing there,
  * so a widen degrades to the literal vocabulary RFC 031 already matches
- * vector-free: the sender clauses `@remit/ui` derives, combined with `Or`, no
- * anchor. The same predicate matches at index time (RFC 034), so a standing
- * filter built from it keeps working on future mail.
+ * vector-free: what the whole selection agrees on, combined with `Or`, no
+ * anchor (#458) — the same evidence order the properties door prefills from,
+ * so a selection with nothing in common on sender still falls back to a
+ * subject it shares rather than one `From` chip per message. The same
+ * predicate matches at index time (RFC 034), so a standing filter built from
+ * it keeps working on future mail.
  */
 
 /**
- * The literal predicate that stands in for the semantic anchor: the sender
- * clauses combined with `Or` and no anchor. The preview, the one-time
- * back-apply, and the standing filter all carry exactly this.
+ * The literal predicate that stands in for the semantic anchor: the clauses
+ * the selection agrees on, combined with `Or` and no anchor. The preview, the
+ * one-time back-apply, and the standing filter all carry exactly this.
  */
 export const buildSenderFallbackDraft = (
 	senders: readonly string[],
+	subjects: readonly string[],
 ): OrganizeDraft => ({
 	matchOperator: "Or",
-	literalClauses: deriveSenderClauses(senders),
+	literalClauses: derivePropertyClauses(senders, subjects),
 });
 
 /**

package/src/lib/thread-search-tokens.ts

@@ -39,9 +39,10 @@ export type ThreadSearchTokenParamName = keyof ThreadSearchTokenParams;
 /**
  * Every parameter `searchThreads` takes, the default set.
  *
- * `listAllThreads` takes all of these except `from` and `subject`, so a caller
- * on that endpoint names its own set and the two tokens come back as residue
- * rather than being silently dropped from a request that never carried them.
+ * `listAllThreads` takes all six as well (#1128), so both callers carry the
+ * same tokens. A caller still names its own set rather than inheriting this
+ * one: the set is what decides which tokens come back as residue, and an
+ * endpoint that grows or loses a parameter has to say so where it is called.
  */
 export const THREAD_SEARCH_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] =
 	["from", "subject", "category", "unread", "starred", "attachments"];