@remit/ui 0.0.57 → 0.0.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/ui",
-  "version": "0.0.57",
+  "version": "0.0.58",
   "type": "module",
   "files": [
     "src"
@@ -26,6 +26,7 @@
     "react-resizable-panels": "^2.1.9",
     "react-simple-pull-to-refresh": "^1.3.4",
     "tailwind-merge": "^2",
+    "tldts": "^7.4.9",
     "@types/dompurify": "*"
   },
   "peerDependencies": {

package/src/index.ts

@@ -598,6 +598,11 @@ export {
 	labelColorOptions,
 	labelDotClass,
 } from "./lib/label-color.js";
+export {
+	derivePropertyClauses,
+	normalizeSubject,
+	sharedSubjectFragment,
+} from "./lib/property-prefill.js";
 export {
 	LIST_ROW_ATTRIBUTE,
 	LIST_ROW_SELECTOR,
@@ -606,6 +611,19 @@ export {
 	type UseRovingFocusOptions,
 	useRovingFocus,
 } from "./lib/roving-focus.js";
+export {
+	buildSearchRule,
+	type DroppedFacet,
+	type DroppedFacetType,
+	isConvertible,
+	type SearchConversion,
+} from "./lib/search-rule.js";
+export {
+	collapsibleDomain,
+	deriveSenderClauses,
+	distinctSenders,
+	senderDomain,
+} from "./lib/sender-derivation.js";
 export {
 	type SuggestAction,
 	type SuggestKeyState,

package/src/lib/property-prefill.test.ts

@@ -0,0 +1,173 @@
+/**
+ * The opening clauses a properties-only rule offers (RFC 038 D2/D4). The
+ * prefill is a starting point the user edits, so the contract worth holding is
+ * the order of evidence — sender before subject, and nothing at all rather than
+ * a guess that matches half a mailbox.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	derivePropertyClauses,
+	normalizeSubject,
+	sharedSubjectFragment,
+} from "./property-prefill.js";
+
+describe("normalizeSubject", () => {
+	it("strips stacked reply, forward, and list decorations", () => {
+		assert.equal(
+			normalizeSubject("Re: Fwd: [ops] Invoice 1841"),
+			"Invoice 1841",
+		);
+		assert.equal(normalizeSubject("RE[2]: Invoice 1841"), "Invoice 1841");
+		assert.equal(normalizeSubject("AW: SV: Invoice 1841"), "Invoice 1841");
+	});
+
+	it("collapses whitespace and trims", () => {
+		assert.equal(normalizeSubject("  Invoice   1841  "), "Invoice 1841");
+	});
+
+	it("leaves a subject that is only decoration empty", () => {
+		assert.equal(normalizeSubject("Re: "), "");
+	});
+});
+
+describe("sharedSubjectFragment", () => {
+	it("takes the longest run of whole words every subject carries", () => {
+		assert.equal(
+			sharedSubjectFragment([
+				"Invoice 1841",
+				"Invoice 1902",
+				"Re: Invoice 2003",
+			]),
+			"Invoice",
+		);
+	});
+
+	it("matches case-insensitively and answers in the first subject's casing", () => {
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "INVOICE 1902"]),
+			"Invoice",
+		);
+	});
+
+	it("compares whole words, never a partial one", () => {
+		// "Invoice 18" is a shared character run and not a shared word run.
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "Invoice 1892"]),
+			"Invoice",
+		);
+	});
+
+	it("keeps a single subject as its own fragment", () => {
+		assert.equal(sharedSubjectFragment(["Invoice 1841"]), "Invoice 1841");
+	});
+
+	it("rejects a single subject that is nothing but filler", () => {
+		assert.equal(sharedSubjectFragment(["for you"]), undefined);
+	});
+
+	it("rejects a shared run of filler words", () => {
+		assert.equal(
+			sharedSubjectFragment(["the report", "the summary"]),
+			undefined,
+		);
+	});
+
+	it("rejects a shared run too short to be worth matching", () => {
+		assert.equal(
+			sharedSubjectFragment(["Q3 numbers", "Q3 results"]),
+			undefined,
+		);
+	});
+
+	it("is undefined when the subjects share nothing", () => {
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "Standup notes"]),
+			undefined,
+		);
+	});
+
+	it("is undefined when no subject survives normalizing", () => {
+		assert.equal(sharedSubjectFragment(["Re:", "   "]), undefined);
+	});
+});
+
+describe("derivePropertyClauses", () => {
+	it("matches on the sender when the whole selection is from one address", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "npm@github.com", "npm@github.com"],
+				["Invoice 1841", "Standup notes", "Deploy failed"],
+			),
+			[{ field: "From", value: "npm@github.com" }],
+		);
+	});
+
+	it("matches on the domain when several senders share one", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "notifications@github.com", "ci@sub.github.com"],
+				["Invoice 1841", "Standup notes", "Deploy failed"],
+			),
+			[{ field: "FromDomain", value: "github.com" }],
+		);
+	});
+
+	it("prefers the sender over the subject even when the subjects share a run", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "npm@github.com"],
+				["Invoice 1841", "Invoice 1902"],
+			),
+			[{ field: "From", value: "npm@github.com" }],
+		);
+	});
+
+	it("falls back to what mixed senders' subjects have in common", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test", "ap@initech.test"],
+				["Invoice 1841", "Invoice 1902", "Re: Invoice 2003"],
+			),
+			[{ field: "Subject", value: "Invoice" }],
+		);
+	});
+
+	it("offers one sender chip each when mixed senders share no subject either", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test"],
+				["Invoice 1841", "Standup notes"],
+			),
+			[
+				{ field: "From", value: "billing@acme.test" },
+				{ field: "From", value: "accounts@globex.test" },
+			],
+		);
+	});
+
+	it("refuses a filler-only subject run rather than prefilling a wide match", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test"],
+				["the report", "the summary"],
+			),
+			[
+				{ field: "From", value: "billing@acme.test" },
+				{ field: "From", value: "accounts@globex.test" },
+			],
+		);
+	});
+
+	it("reads a single message as its own sender", () => {
+		assert.deepEqual(
+			derivePropertyClauses(["billing@acme.test"], ["Invoice 1841"]),
+			[{ field: "From", value: "billing@acme.test" }],
+		);
+	});
+
+	it("offers nothing when the selection carries no sender and no shared subject", () => {
+		assert.deepEqual(derivePropertyClauses([], ["Re:", "   "]), []);
+	});
+});

package/src/lib/property-prefill.ts

@@ -0,0 +1,151 @@
+import type { RuleClause } from "../components/filter-rule.js";
+import { deriveSenderClauses, distinctSenders } from "./sender-derivation.js";
+
+/**
+ * The opening clauses for a rule matched on properties alone — no semantic
+ * anchor (RFC 038 D2/D4). The selection is the only evidence available, so the
+ * prefill reads it in the order the evidence is strongest:
+ *
+ * 1. One sender across the whole selection, or several that collapse to one
+ *    registrable domain — the sender derivation (#251, #262) already decides
+ *    between a `From` and a `FromDomain` clause, and this reuses it rather than
+ *    deciding again.
+ * 2. Mixed senders — what the messages share is their subject, so match on the
+ *    part the subjects have in common instead.
+ * 3. Neither — no clauses. The editor opens empty and asks for one; a wrong
+ *    guess costs more than an absent one.
+ *
+ * Every clause it produces is an ordinary chip: visible, editable, removable.
+ * It is where the user starts, never what the rule is.
+ */
+
+/** Reply, forward, and list-tag decorations that carry no meaning for a match. */
+const SUBJECT_PREFIX =
+	/^\s*(?:(?:re|aw|fwd?|vs|sv|antw|res|enc|tr)\s*(?:\[\d+\])?\s*:|\[[^\]]{1,32}\])\s*/i;
+
+/**
+ * A subject reduced to the part worth matching on: reply and forward markers
+ * and leading list tags stripped (repeatedly — real threads stack them), and
+ * whitespace collapsed.
+ */
+export const normalizeSubject = (subject: string): string => {
+	let value = subject.replace(/\s+/g, " ").trim();
+	for (;;) {
+		const stripped = value.replace(SUBJECT_PREFIX, "");
+		if (stripped === value) return value.trim();
+		value = stripped;
+	}
+};
+
+/**
+ * Words too common to be a rule on their own. A single shared word from this
+ * list matches half a mailbox, which is worse than offering nothing.
+ */
+const WEAK_WORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"by",
+	"for",
+	"from",
+	"has",
+	"have",
+	"in",
+	"is",
+	"it",
+	"me",
+	"my",
+	"new",
+	"of",
+	"on",
+	"or",
+	"our",
+	"the",
+	"this",
+	"to",
+	"was",
+	"we",
+	"with",
+	"you",
+	"your",
+]);
+
+/** The shortest fragment worth prefilling as a `Subject` clause. */
+const MIN_FRAGMENT_LENGTH = 3;
+
+const words = (subject: string): string[] =>
+	subject.split(" ").filter((word) => word !== "");
+
+const isUseful = (fragment: string[]): boolean => {
+	if (fragment.length === 0) return false;
+	if (fragment.join(" ").length < MIN_FRAGMENT_LENGTH) return false;
+	return fragment.some((word) => !WEAK_WORDS.has(word.toLowerCase()));
+};
+
+const runAt = (haystack: string[], needle: string[]): number =>
+	haystack.findIndex((_, start) =>
+		needle.every(
+			(word, offset) =>
+				haystack[start + offset]?.toLowerCase() === word.toLowerCase(),
+		),
+	);
+
+/**
+ * The longest run of whole words every subject carries, compared
+ * case-insensitively and returned in the casing the first subject uses. Whole
+ * words rather than raw characters, so "Invoice 1841" and "Invoice 1902" share
+ * "Invoice" and not "Invoice 18".
+ *
+ * `undefined` when the subjects share nothing worth matching on — a single
+ * filler word does not count.
+ */
+export const sharedSubjectFragment = (
+	subjects: readonly string[],
+): string | undefined => {
+	const normalized = subjects
+		.map(normalizeSubject)
+		.filter((subject) => subject !== "");
+	if (normalized.length === 0) return undefined;
+	const [first, ...rest] = normalized;
+	if (rest.length === 0) return isUseful(words(first)) ? first : undefined;
+
+	const firstWords = words(first);
+	for (let length = firstWords.length; length > 0; length -= 1) {
+		for (let start = 0; start + length <= firstWords.length; start += 1) {
+			const candidate = firstWords.slice(start, start + length);
+			if (!isUseful(candidate)) continue;
+			if (rest.every((subject) => runAt(words(subject), candidate) >= 0)) {
+				return candidate.join(" ");
+			}
+		}
+	}
+	return undefined;
+};
+
+/**
+ * The clauses a properties-only rule opens on, derived from the selected
+ * messages' senders and subjects. Empty when the selection gives nothing to go
+ * on — the editor then holds the commit until the user adds a clause, which is
+ * the honest state.
+ */
+export const derivePropertyClauses = (
+	senders: readonly string[],
+	subjects: readonly string[],
+): Omit<RuleClause, "id">[] => {
+	const senderClauses = deriveSenderClauses(senders);
+	// One sender across the selection, or several on one registrable domain:
+	// a single sharp clause, and sharper than any subject fragment.
+	if (distinctSenders(senders).length === 1) return senderClauses;
+	if (senderClauses.length === 1 && senderClauses[0].field === "FromDomain")
+		return senderClauses;
+
+	const fragment = sharedSubjectFragment(subjects);
+	if (fragment !== undefined) return [{ field: "Subject", value: fragment }];
+	// Mixed senders with nothing shared in their subjects: one `From` chip each,
+	// the sender derivation's own answer (#251).
+	return senderClauses;
+};

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

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	buildSearchRule,
+	isConvertible,
+	type SearchConversion,
+} from "./search-rule.js";
+
+const conversion = (
+	overrides: Partial<SearchConversion> = {},
+): SearchConversion => ({
+	clauses: [],
+	matchOperator: "all",
+	droppedFacets: [],
+	keptTerms: false,
+	droppedSemantic: false,
+	...overrides,
+});
+
+describe("isConvertible", () => {
+	it("is false when the search yields no clause", () => {
+		assert.equal(
+			isConvertible(
+				conversion({
+					droppedFacets: [{ type: "hasAttachment", label: "Has attachment" }],
+					scopedOut: { mailboxId: "mbx-archive", label: "archive" },
+				}),
+			),
+			false,
+		);
+	});
+
+	it("is true once a term or sender is present", () => {
+		assert.equal(
+			isConvertible(
+				conversion({
+					clauses: [{ field: "HasWords", value: "receipts" }],
+					keptTerms: true,
+				}),
+			),
+			true,
+		);
+	});
+});
+
+describe("buildSearchRule", () => {
+	it("builds a standing rule with stable clause ids, no widen, empty name", () => {
+		const rule = buildSearchRule(
+			conversion({
+				clauses: [
+					{ field: "From", value: "a@b.com" },
+					{ field: "HasWords", value: "nightly" },
+				],
+			}),
+		);
+		assert.equal(rule.scope, "standing");
+		assert.equal(rule.widen, undefined);
+		assert.equal(rule.name, "");
+		assert.deepEqual(
+			rule.clauses.map((clause) => clause.id),
+			["search-0", "search-1"],
+		);
+	});
+
+	it("honors an explicit scope and move target", () => {
+		const rule = buildSearchRule(
+			conversion({ clauses: [{ field: "HasWords", value: "nightly" }] }),
+			{ scope: "once", moveMailboxId: "mbx-archive" },
+		);
+		assert.equal(rule.scope, "once");
+		assert.equal(rule.moveMailboxId, "mbx-archive");
+	});
+});

package/src/lib/search-rule.ts

@@ -0,0 +1,96 @@
+/**
+ * What a search converts to, and the rule built from it (RFC 038 D5). The shape
+ * carries the clauses alongside everything the search held that a filter cannot,
+ * so a conversion can never drop a facet without saying so; `search-conversion.ts`
+ * beside it owns the copy that states it.
+ */
+
+import type {
+	ClauseField,
+	FilterRule,
+	MatchOperator,
+	RuleScope,
+} from "../components/filter-rule.js";
+
+/**
+ * A search facet a filter has no clause for. Attachment, read state, starred,
+ * category and the date bounds are attributes of a message, not text a clause
+ * matches on.
+ */
+export type DroppedFacetType =
+	| "hasAttachment"
+	| "isUnread"
+	| "isRead"
+	| "isStarred"
+	| "category"
+	| "before"
+	| "after";
+
+export interface DroppedFacet {
+	type: DroppedFacetType;
+	/** What was dropped, named for the user (e.g. "Has attachment", "Before 2026-01-01"). */
+	label: string;
+}
+
+export interface ScopedOutFolder {
+	mailboxId: string;
+	/** The folder the search was limited to. */
+	label: string;
+}
+
+export interface SearchConversion {
+	/** Clauses derived from the search — `From` (a `from:` facet) and `HasWords` (the free text). */
+	clauses: { field: ClauseField; value: string }[];
+	matchOperator: MatchOperator;
+	/** A folder an `in:` facet scoped the search to — kept OUT of the rule (never silently unscoped). */
+	scopedOut?: ScopedOutFolder;
+	/** Facets with no clause equivalent, each named. */
+	droppedFacets: DroppedFacet[];
+	/** The account an `account:` facet targets — the filter is created for it. */
+	targetAccountId?: string;
+	/** The search carried free-text terms, kept as a `HasWords` clause. */
+	keptTerms: boolean;
+	/**
+	 * The filter this conversion builds is always literal-only — free text has no
+	 * anchor message for a semantic widen — so the search's semantic "similar mail"
+	 * reach is dropped whenever the search had one (RFC 038 D5). True exactly when
+	 * free text was kept AND the search surfaced semantically-similar mail; on a
+	 * deployment with no semantic reach there was nothing to drop, so no note.
+	 */
+	droppedSemantic: boolean;
+}
+
+/**
+ * Whether the conversion yields a rule with something to match. A search of only
+ * dropped facets or a bare folder scope converts to no clauses, so there is no
+ * filter to open — the entry point offers nothing rather than an empty editor.
+ */
+export const isConvertible = (conversion: SearchConversion): boolean =>
+	conversion.clauses.length > 0;
+
+interface BuildRuleOptions {
+	scope?: RuleScope;
+	moveMailboxId?: string;
+}
+
+/**
+ * The rule the editor opens on, from a conversion. A search-derived rule defaults
+ * to a standing filter — "make this a filter" is a request to keep applying it —
+ * and the editor lets the user drop it back to a one-time apply. It carries no
+ * widen: a free-text query has no message anchor, so the semantic chip is not
+ * offered on this surface (its loss is stated in the conversion notice instead).
+ */
+export const buildSearchRule = (
+	conversion: SearchConversion,
+	{ scope = "standing", moveMailboxId }: BuildRuleOptions = {},
+): FilterRule => ({
+	clauses: conversion.clauses.map((clause, index) => ({
+		id: `search-${index}`,
+		field: clause.field,
+		value: clause.value,
+	})),
+	matchOperator: conversion.matchOperator,
+	moveMailboxId,
+	scope,
+	name: "",
+});

package/src/lib/sender-derivation.test.ts

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	collapsibleDomain,
+	deriveSenderClauses,
+	distinctSenders,
+} from "./sender-derivation.js";
+
+describe("distinctSenders", () => {
+	it("drops empties and blanks, trimming what remains", () => {
+		assert.deepEqual(
+			distinctSenders(["  npm@github.com ", "", "   ", "a@x.com"]),
+			["npm@github.com", "a@x.com"],
+		);
+	});
+
+	it("de-duplicates case-insensitively, keeping first-seen casing and order", () => {
+		assert.deepEqual(
+			distinctSenders([
+				"NPM@github.com",
+				"a@x.com",
+				"npm@GITHUB.com",
+				"a@x.com",
+			]),
+			["NPM@github.com", "a@x.com"],
+		);
+	});
+});
+
+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 when domains differ", () => {
+		assert.deepEqual(
+			deriveSenderClauses(["npm@github.com", "npm@github.com", "a@x.com"]),
+			[
+				{ field: "From", value: "npm@github.com" },
+				{ field: "From", value: "a@x.com" },
+			],
+		);
+	});
+
+	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(["", "  "]), []);
+	});
+
+	it("collapses a multi-label public suffix to the registrable domain", () => {
+		// The public-suffix list is what makes this foo.co.uk; the trailing two
+		// labels of the host are co.uk, which matches every British domain.
+		assert.deepEqual(deriveSenderClauses(["a@foo.co.uk", "b@foo.co.uk"]), [
+			{ field: "FromDomain", value: "foo.co.uk" },
+		]);
+	});
+});

package/src/lib/sender-derivation.ts

@@ -0,0 +1,85 @@
+/**
+ * Senders in a selection turned into clauses (RFC 038 D2).
+ *
+ * The widen fallback for a deployment that ships no vector pipeline reaches for
+ * this: the semantic anchor matches nothing there, so a widen degrades to the
+ * literal vocabulary RFC 031 already matches vector-free — one `From` clause per
+ * distinct sender, or a single `FromDomain` clause when they all sit on one
+ * registrable domain. The same predicate matches at index time (RFC 034), so a
+ * standing filter built from it keeps working on future mail.
+ */
+
+import { getDomain } from "tldts";
+import type { RuleClause } from "../components/filter-rule.js";
+
+/**
+ * Distinct sender addresses from the selection, trimmed, empties dropped, and
+ * de-duplicated case-insensitively while preserving first-seen casing and order.
+ */
+export const distinctSenders = (senders: readonly string[]): string[] => {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const raw of senders) {
+		const value = raw.trim();
+		if (value === "") continue;
+		const key = value.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(value);
+	}
+	return out;
+};
+
+const hostOf = (address: string): string => {
+	const at = address.lastIndexOf("@");
+	return at >= 0 ? address.slice(at + 1) : address;
+};
+
+/**
+ * The registrable domain behind a sender address, public-suffix aware (tldts
+ * `getDomain`), or `null` when the address carries none. The one place an
+ * address is turned into a `FromDomain` value — a clause the prefill derives and
+ * a domain the value field suggests must be the same string, or the suggestion
+ * would offer a domain the matcher never produces.
+ */
+export const senderDomain = (address: string): string | null =>
+	getDomain(hostOf(address.trim()));
+
+/**
+ * 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 = senderDomain(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[],
+): Omit<RuleClause, "id">[] => {
+	const domain = collapsibleDomain(senders);
+	if (domain !== null) return [{ field: "FromDomain", value: domain }];
+	return distinctSenders(senders).map(
+		(value): Omit<RuleClause, "id"> => ({ field: "From", value }),
+	);
+};