@remit/web-client 0.0.64 → 0.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.64",
+  "version": "0.0.65",
   "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": {
@@ -89,6 +89,7 @@
     "react-i18next": "^15",
     "react-resizable-panels": "^2.1.9",
     "tailwind-merge": "^2",
+    "tldts": "^7.4.9",
     "vaul": "^1.1.2",
     "zod": "^3",
     "@types/dompurify": "*"

package/src/components/mail/organize/OrganizePanel.render.test.ts

@@ -76,18 +76,18 @@ describe("OrganizePanel", () => {
 		const html = render({
 			matchedCount: 128,
 			semanticUnavailable: true,
-			senders: ["npm@github.com", "notifications@github.com"],
+			senders: ["npm@github.com", "digest@substack.com"],
 			matchPredicate: {
 				matchOperator: "Or",
 				literalClauses: [
 					{ field: "From", value: "npm@github.com" },
-					{ field: "From", value: "notifications@github.com" },
+					{ field: "From", value: "digest@substack.com" },
 				],
 			},
 		});
 		assert.match(html, /matching all mail from/);
 		assert.match(html, /npm@github\.com/);
-		assert.match(html, /notifications@github\.com/);
+		assert.match(html, /digest@substack\.com/);
 		assert.match(html, /128 matches/);
 		// Never claims the matched set is semantically similar (only denies that
 		// similar-mail matching is available).
@@ -98,6 +98,25 @@ describe("OrganizePanel", () => {
 		assert.match(html, /All like these/);
 	});
 
+	it("names the shared domain when every fallback sender shares one (RFC 038 D2 collapse)", () => {
+		const html = render({
+			matchedCount: 342,
+			semanticUnavailable: true,
+			senders: [
+				"npm@github.com",
+				"notifications@github.com",
+				"ci@sub.github.com",
+			],
+			matchPredicate: {
+				matchOperator: "Or",
+				literalClauses: [{ field: "FromDomain", value: "github.com" }],
+			},
+		});
+		assert.match(html, /matching all mail from anyone at github\.com/);
+		assert.match(html, /342 matches/);
+		assert.doesNotMatch(html, /similar message/i);
+	});
+
 	it("pre-selects the seeded scope (a 'Something else' shortcut seeds the sentence)", () => {
 		const html = render({ initialScope: "standing" });
 		// The standing scope's "Always keep" phrasing only renders when it is active.

package/src/components/mail/organize/smart-organize.stories.tsx

@@ -227,10 +227,11 @@ export const SemanticUnavailable: Story = {
 
 /**
  * No vector pipeline, but the selection has senders to match on — the widen
- * fell back to matching all mail from those senders. The heading names the
- * senders and states the real semantics, and every commit scope (including the
- * standing filter) carries the sender `From` clauses, so it reaches the widened
- * set and keeps working on future mail.
+ * fell back to matching all mail from those senders. The senders span different
+ * domains, so the fallback keeps one `From` clause per address; the heading
+ * names the senders and states the real semantics, and every commit scope
+ * (including the standing filter) carries those clauses, so it reaches the
+ * widened set and keeps working on future mail.
  */
 export const SenderFallback: Story = {
 	name: "Sender Fallback",
@@ -244,12 +245,44 @@ export const SenderFallback: Story = {
 					matchOperator: "Or",
 					literalClauses: [
 						{ field: "From", value: "npm@github.com" },
-						{ field: "From", value: "notifications@github.com" },
+						{ field: "From", value: "noreply@medium.com" },
 					],
 				}}
 				matchedCount={128}
 				semanticUnavailable
-				senders={["npm@github.com", "notifications@github.com"]}
+				senders={["npm@github.com", "noreply@medium.com"]}
+				onClose={() => undefined}
+			/>
+		</SheetStage>
+	),
+};
+
+/**
+ * The sender fallback where every selected sender shares one registrable domain
+ * (RFC 038 D2): the per-address `From` chips collapse to a single `FromDomain`
+ * clause, and the heading names the domain — "anyone at github.com" — rather
+ * than listing addresses. Matches `sub.github.com` too, never a look-alike like
+ * `github.com.evil.example`.
+ */
+export const SenderFallbackDomain: Story = {
+	name: "Sender Fallback (domain)",
+	render: () => (
+		<SheetStage>
+			<OrganizePanel
+				accountId={ACCOUNT_ID}
+				mailboxId="mbx-inbox"
+				selectedMessageIds={["msg-1", "msg-2", "msg-3"]}
+				matchPredicate={{
+					matchOperator: "Or",
+					literalClauses: [{ field: "FromDomain", value: "github.com" }],
+				}}
+				matchedCount={342}
+				semanticUnavailable
+				senders={[
+					"npm@github.com",
+					"notifications@github.com",
+					"ci@sub.github.com",
+				]}
 				onClose={() => undefined}
 			/>
 		</SheetStage>

package/src/lib/organize/organize-copy.test.ts

@@ -131,4 +131,12 @@ describe("senderFallbackSummary", () => {
 		assert.match(summary, /isn't available on this server/);
 		assert.match(summary, /matching all mail from npm@github\.com instead/);
 	});
+
+	it("names the shared domain when the senders collapse to one FromDomain", () => {
+		const summary = senderFallbackSummary(["npm@github.com", "ci@github.com"]);
+		assert.match(
+			summary,
+			/matching all mail from anyone at github\.com instead/,
+		);
+	});
 });

package/src/lib/organize/organize-copy.ts

@@ -1,5 +1,6 @@
 import type { OrganizeScope } from "./organize-model";
 import { hasCommittableAction, type OrganizeDraft } from "./organize-model";
+import { collapsibleDomain } from "./sender-fallback";
 
 export interface CommitContext {
 	draft: OrganizeDraft;
@@ -82,9 +83,13 @@ export const formatSenderList = (senders: readonly string[]): string => {
 /**
  * The heading when the widen fell back to sender matching (no vector pipeline on
  * this server). States the actual semantics — matching every mail from these
- * senders — and never claims semantic similarity.
+ * senders, or from anyone at their shared domain when the clauses collapsed to a
+ * single `FromDomain` (RFC 038 D2) — and never claims semantic similarity.
  */
-export const senderFallbackSummary = (senders: readonly string[]): string =>
-	`Similar-mail matching isn't available on this server — matching all mail from ${formatSenderList(
-		senders,
-	)} instead.`;
+export const senderFallbackSummary = (senders: readonly string[]): string => {
+	const domain = collapsibleDomain(senders);
+	const target = domain
+		? `anyone at ${domain}`
+		: `${formatSenderList(senders)}`;
+	return `Similar-mail matching isn't available on this server — matching all mail from ${target} instead.`;
+};

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

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
 	buildSenderFallbackDraft,
+	collapsibleDomain,
 	deriveSenderClauses,
 	distinctSenders,
 } from "./sender-fallback";
@@ -27,8 +28,36 @@ describe("distinctSenders", () => {
 	});
 });
 
+describe("collapsibleDomain", () => {
+	it("returns the shared registrable domain when every sender matches it", () => {
+		assert.equal(
+			collapsibleDomain([
+				"npm@github.com",
+				"notifications@github.com",
+				"ci@sub.github.com",
+			]),
+			"github.com",
+		);
+	});
+
+	it("does not collapse a single sender to its whole domain", () => {
+		assert.equal(collapsibleDomain(["npm@github.com"]), null);
+	});
+
+	it("does not collapse when a sender's domain differs", () => {
+		assert.equal(collapsibleDomain(["npm@github.com", "a@x.com"]), null);
+	});
+
+	it("does not collapse when any sender's domain cannot be resolved", () => {
+		assert.equal(
+			collapsibleDomain(["npm@github.com", "malformed-no-at-sign"]),
+			null,
+		);
+	});
+});
+
 describe("deriveSenderClauses", () => {
-	it("emits one From clause per distinct sender", () => {
+	it("emits one From clause per distinct sender when domains differ", () => {
 		assert.deepEqual(
 			deriveSenderClauses(["npm@github.com", "npm@github.com", "a@x.com"]),
 			[
@@ -38,6 +67,32 @@ describe("deriveSenderClauses", () => {
 		);
 	});
 
+	it("collapses to a single FromDomain clause when every sender shares a domain", () => {
+		assert.deepEqual(
+			deriveSenderClauses([
+				"npm@github.com",
+				"notifications@github.com",
+				"ci@sub.github.com",
+			]),
+			[{ field: "FromDomain", value: "github.com" }],
+		);
+	});
+
+	it("keeps per-address From clauses for the mixed case", () => {
+		assert.deepEqual(
+			deriveSenderClauses([
+				"npm@github.com",
+				"ci@github.com",
+				"newsletter@example.org",
+			]),
+			[
+				{ field: "From", value: "npm@github.com" },
+				{ field: "From", value: "ci@github.com" },
+				{ field: "From", value: "newsletter@example.org" },
+			],
+		);
+	});
+
 	it("is empty when no sender survives", () => {
 		assert.deepEqual(deriveSenderClauses(["", "  "]), []);
 	});
@@ -53,4 +108,12 @@ describe("buildSenderFallbackDraft", () => {
 			{ field: "From", value: "a@x.com" },
 		]);
 	});
+
+	it("carries a single FromDomain clause when the senders share a domain", () => {
+		const draft = buildSenderFallbackDraft(["npm@github.com", "ci@github.com"]);
+		assert.equal(draft.matchOperator, "Or");
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "FromDomain", value: "github.com" },
+		]);
+	});
 });

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

@@ -2,6 +2,7 @@ import type {
 	RemitImapFilterClause,
 	RemitImapOrganizeInput,
 } from "@remit/api-http-client/types.gen.ts";
+import { getDomain } from "tldts";
 import type { OrganizeDraft } from "./organize-model";
 
 /**
@@ -31,15 +32,47 @@ export const distinctSenders = (senders: readonly string[]): string[] => {
 	return out;
 };
 
+const hostOf = (address: string): string => {
+	const at = address.lastIndexOf("@");
+	return at >= 0 ? address.slice(at + 1) : address;
+};
+
 /**
- * One `From` literal clause per distinct sender address. A `From` clause matches
- * the sender address or display name (match.ts `clauseMatches`), so the address
- * is the precise, stable key.
+ * The single registrable domain the whole selection collapses to, or `null` when
+ * it does not collapse. A collapse needs at least two distinct senders that all
+ * resolve to one registrable domain (public-suffix aware, via tldts `getDomain`)
+ * — the "anyone at this domain" signal (RFC 038 D2). One sender stays a precise
+ * `From` clause rather than widening a single address to its whole domain, and a
+ * sender whose domain can't be resolved blocks the collapse.
+ */
+export const collapsibleDomain = (
+	senders: readonly string[],
+): string | null => {
+	const distinct = distinctSenders(senders);
+	if (distinct.length < 2) return null;
+	let shared: string | null = null;
+	for (const sender of distinct) {
+		const domain = getDomain(hostOf(sender));
+		if (domain === null) return null;
+		if (shared === null) shared = domain;
+		else if (shared !== domain) return null;
+	}
+	return shared;
+};
+
+/**
+ * The literal clauses standing in for the selection. When every sender shares one
+ * registrable domain, a single `FromDomain` clause replaces the per-address `From`
+ * chips (RFC 038 D2); otherwise one `From` clause per distinct sender, each
+ * matching the sender address or display name (match.ts `clauseMatches`).
  */
 export const deriveSenderClauses = (
 	senders: readonly string[],
-): RemitImapFilterClause[] =>
-	distinctSenders(senders).map((value) => ({ field: "From", value }));
+): RemitImapFilterClause[] => {
+	const domain = collapsibleDomain(senders);
+	if (domain !== null) return [{ field: "FromDomain", value: domain }];
+	return distinctSenders(senders).map((value) => ({ field: "From", value }));
+};
 
 /**
  * The literal predicate that stands in for the semantic anchor: the sender `From`