@remit/web-client 0.0.86 → 0.0.88

package/src/lib/organize/clause-suggestions.ts

@@ -0,0 +1,89 @@
+import { type ClauseField, type Suggestion, senderDomain } from "@remit/ui";
+
+/**
+ * Values worth offering while a clause is being typed. The rule editor's value
+ * field used to be bare text entry, so a `From` clause meant recalling an
+ * address exactly and a `FromDomain` clause meant knowing what the matcher
+ * considers a registrable domain.
+ *
+ * The offer is a shortcut and never a constraint: nothing here can reject or
+ * rewrite what the user typed, and a field with no matches is the plain text box
+ * it always was.
+ */
+
+/** An address a suggestion can be built from. */
+export interface KnownAddress {
+	email: string;
+	displayName?: string;
+	/**
+	 * The address came off the messages the user selected, rather than a lookup.
+	 * These are the likeliest answers, so they lead the list and say where they
+	 * came from.
+	 */
+	fromSelection?: boolean;
+}
+
+/** How many suggestions the list shows at most. */
+export const CLAUSE_SUGGESTION_LIMIT = 8;
+
+/**
+ * Whether a clause field takes values that come from addresses. `Subject`,
+ * `HasWords`, and `ListId` are free text with nothing to draw on, and stay so.
+ */
+export const fieldTakesAddressSuggestions = (field: ClauseField): boolean =>
+	field === "From" || field === "FromDomain";
+
+const addressSuggestion = (address: KnownAddress): Suggestion => ({
+	value: address.email,
+	label: address.displayName ?? address.email,
+	...(address.displayName ? { hint: address.email } : {}),
+	...(address.fromSelection ? { source: "selected" } : {}),
+});
+
+const domainSuggestion = (address: KnownAddress): Suggestion | undefined => {
+	const domain = senderDomain(address.email);
+	if (domain === null) return undefined;
+	return {
+		value: domain,
+		...(address.fromSelection ? { source: "selected" } : {}),
+	};
+};
+
+const matches = (suggestion: Suggestion, query: string): boolean =>
+	suggestion.value.toLowerCase().includes(query) ||
+	(suggestion.label ?? "").toLowerCase().includes(query);
+
+/**
+ * The suggestions for one clause draft. `addresses` is given in priority order —
+ * the selection's own senders first — and duplicates collapse onto the first
+ * occurrence, so a selected address keeps its "selected" marking even when a
+ * lookup returns it too.
+ *
+ * An empty query offers the lot, which is what makes the selection's addresses
+ * available before a single key is pressed. A query that exactly matches an
+ * offer drops it: there is nothing left to shortcut.
+ */
+export const buildClauseSuggestions = (
+	field: ClauseField,
+	query: string,
+	addresses: readonly KnownAddress[],
+): Suggestion[] => {
+	if (!fieldTakesAddressSuggestions(field)) return [];
+	const needle = query.trim().toLowerCase();
+	const seen = new Set<string>();
+	const out: Suggestion[] = [];
+	for (const address of addresses) {
+		if (address.email.trim() === "") continue;
+		const suggestion =
+			field === "From" ? addressSuggestion(address) : domainSuggestion(address);
+		if (!suggestion) continue;
+		const key = suggestion.value.toLowerCase();
+		if (key === "" || seen.has(key)) continue;
+		seen.add(key);
+		if (key === needle) continue;
+		if (needle !== "" && !matches(suggestion, needle)) continue;
+		out.push(suggestion);
+		if (out.length === CLAUSE_SUGGESTION_LIMIT) break;
+	}
+	return out;
+};

package/src/lib/organize/rule-model.test.ts

@@ -11,6 +11,7 @@ import { buildOrganizeInput } from "./organize-model";
 import {
 	buildInitialRule,
 	derivePreview,
+	isEvaluablePredicate,
 	normalizeClauseValue,
 	normalizeListId,
 	predicateSignature,
@@ -300,3 +301,59 @@ describe("derivePreview", () => {
 		);
 	});
 });
+
+describe("isEvaluablePredicate", () => {
+	it("accepts literal clauses the vector-free matcher can read off the index", () => {
+		assert.equal(
+			isEvaluablePredicate({
+				matchOperator: "And",
+				literalClauses: [
+					{ field: "From", value: "npm@github.com" },
+					{ field: "Subject", value: "Invoice" },
+				],
+			}),
+			true,
+		);
+	});
+
+	it("rejects a body clause with no anchor — the shape that answered 500", () => {
+		assert.equal(
+			isEvaluablePredicate({
+				matchOperator: "And",
+				literalClauses: [{ field: "HasWords", value: "receipt" }],
+			}),
+			false,
+		);
+	});
+
+	it("rejects it however it is mixed in with clauses that are evaluable", () => {
+		assert.equal(
+			isEvaluablePredicate({
+				matchOperator: "Or",
+				literalClauses: [
+					{ field: "From", value: "npm@github.com" },
+					{ field: "HasWords", value: "receipt" },
+				],
+			}),
+			false,
+		);
+	});
+
+	it("accepts a body clause once an anchor puts the matcher on the semantic arm", () => {
+		assert.equal(
+			isEvaluablePredicate({
+				anchorMessageId: "msg-1",
+				matchOperator: "And",
+				literalClauses: [{ field: "HasWords", value: "receipt" }],
+			}),
+			true,
+		);
+	});
+
+	it("accepts an empty predicate", () => {
+		assert.equal(
+			isEvaluablePredicate({ matchOperator: "And", literalClauses: [] }),
+			true,
+		);
+	});
+});

package/src/lib/organize/rule-model.ts

@@ -1,17 +1,16 @@
-import type {
-	ClauseField,
-	FilterRule,
-	MatchOperator,
-	PreviewCount,
-	RuleClause,
-	RuleScope,
+import {
+	type ClauseField,
+	derivePropertyClauses,
+	type FilterRule,
+	type MatchOperator,
+	type PreviewCount,
+	type RuleClause,
+	type RuleMatchMode,
+	type RuleScope,
 } from "@remit/ui";
 import { pickedDateToExpiresAt } from "./filter-status";
 import type { OrganizeDraft } from "./organize-model";
-import {
-	deriveSenderClauses,
-	type OrganizeMatchPredicate,
-} from "./sender-fallback";
+import type { OrganizeMatchPredicate } from "./sender-fallback";
 
 /**
  * The clause fields the Organize editor may offer (RFC 038 D2). Gated on what
@@ -55,11 +54,19 @@ export interface InitialRuleInput {
 	anchorMessageId?: string;
 	/**
 	 * The deployment ships no vector pipeline, so the widen cannot run. The rule
-	 * opens on the sender-derived literal clauses instead of an anchor.
+	 * opens on the property-derived literal clauses instead of an anchor.
 	 */
 	semanticUnavailable: boolean;
-	/** Distinct sender addresses of the selection, for the fallback clauses. */
+	/**
+	 * How the rule opens. Defaults to `properties` when the deployment cannot
+	 * serve the widen, `similar` otherwise — semantic stays the default wherever
+	 * it can run.
+	 */
+	matchMode?: RuleMatchMode;
+	/** Distinct sender addresses of the selection, for the derived clauses. */
 	senders: readonly string[];
+	/** Subjects of the selected messages, for the shared-subject prefill. */
+	subjects?: readonly string[];
 	/** How many messages the selection holds — the widen's anchor count. */
 	selectionCount: number;
 	/** A folder a "Something else" shortcut pre-picked. */
@@ -68,41 +75,96 @@ export interface InitialRuleInput {
 	seedScope?: RuleScope;
 }
 
+export const defaultMatchMode = (
+	semanticUnavailable: boolean,
+): RuleMatchMode => (semanticUnavailable ? "properties" : "similar");
+
+/** The property prefill as editor chips, flagged as derived so a mode switch
+ *  can take back its own guesses without touching a clause the user wrote. */
+const derivedClauses = (
+	senders: readonly string[],
+	subjects: readonly string[],
+): RuleClause[] =>
+	derivePropertyClauses(senders, subjects).map((clause, index) => ({
+		id: `derived-${index}`,
+		field: clause.field,
+		value: clause.value,
+		derived: true,
+	}));
+
+export interface RuleMatchers {
+	clauses: RuleClause[];
+	matchOperator: MatchOperator;
+	widen?: FilterRule["widen"];
+}
+
+export interface MatchersInput {
+	anchorMessageId?: string;
+	senders: readonly string[];
+	subjects: readonly string[];
+	selectionCount: number;
+	/** Clauses the user wrote, carried across a mode switch untouched. */
+	keepClauses?: RuleClause[];
+	/** The operator to keep when the user already has clauses of their own. */
+	currentOperator?: MatchOperator;
+}
+
 /**
- * The rule the editor opens on, built from the widen probe. A semantic-capable
- * deployment opens on the widen chip (the anchor, no literal clauses); one
- * without the vector pipeline opens on the sender-fallback `From` chips (#251),
- * visible and editable, matched with `Or`. Either way the move destination and
- * scope come from any "Something else" seed.
+ * What a rule matches on in a given mode, with the action and scope left alone.
+ *
+ * - `similar` — the semantic widen chip, the anchor doing the work.
+ * - `properties` — no anchor at all: the selection's own sender or shared
+ *   subject as ordinary literal chips ({@link derivePropertyClauses}).
+ *
+ * Both keep clauses the user added by hand, so switching mode is never
+ * destructive of their own edits.
  */
-export const buildInitialRule = (input: InitialRuleInput): FilterRule => {
-	const scope = input.seedScope ?? "once";
-	if (input.semanticUnavailable) {
-		// The same derivation the widen fallback runs (#251, #262): one `From`
-		// clause per sender, or a single `FromDomain` clause when they share a
-		// registrable domain. Surfaced as ordinary editable chips.
-		const clauses: RuleClause[] = deriveSenderClauses(input.senders).map(
-			(clause, index) => ({
-				id: `derived-${index}`,
-				field: clause.field,
-				value: clause.value,
-				derived: true,
-			}),
+export const matchersForMode = (
+	mode: RuleMatchMode,
+	input: MatchersInput,
+): RuleMatchers => {
+	const kept = input.keepClauses ?? [];
+	if (mode === "properties") {
+		const prefill = derivedClauses(input.senders, input.subjects).filter(
+			(clause) =>
+				!kept.some(
+					(existing) =>
+						existing.field === clause.field && existing.value === clause.value,
+				),
 		);
 		return {
-			clauses,
-			matchOperator: "any",
-			moveMailboxId: input.seedMailboxId,
-			scope,
-			name: "",
+			clauses: [...kept, ...prefill],
+			matchOperator: kept.length > 0 ? (input.currentOperator ?? "any") : "any",
+			widen: undefined,
 		};
 	}
 	return {
-		clauses: [],
-		matchOperator: "all",
+		clauses: kept,
+		matchOperator: kept.length > 0 ? (input.currentOperator ?? "all") : "all",
 		widen: input.anchorMessageId
 			? { anchorCount: Math.max(input.selectionCount, 1) }
 			: undefined,
+	};
+};
+
+/**
+ * The rule the editor opens on, built from the widen probe. A semantic-capable
+ * deployment opens on the widen chip (the anchor, no literal clauses); one
+ * without the vector pipeline, or a user who picked properties matching, opens
+ * on the derived `From` / `FromDomain` / `Subject` chips (#251), visible and
+ * editable, matched with `Or`. Either way the move destination and scope come
+ * from any "Something else" seed.
+ */
+export const buildInitialRule = (input: InitialRuleInput): FilterRule => {
+	const scope = input.seedScope ?? "once";
+	const mode = input.matchMode ?? defaultMatchMode(input.semanticUnavailable);
+	return {
+		...matchersForMode(mode, {
+			anchorMessageId: input.anchorMessageId,
+			senders: input.senders,
+			subjects: input.subjects ?? [],
+			selectionCount: input.selectionCount,
+		}),
 		moveMailboxId: input.seedMailboxId,
 		scope,
 		name: "",
@@ -132,6 +194,23 @@ export const rulePredicate = (
 	};
 };
 
+/**
+ * Whether the matcher behind `/organize/preview` can evaluate this predicate at
+ * all. Without an anchor it takes the vector-free literal arm, which reads no
+ * message body and rejects a `HasWords` clause rather than narrowing the match
+ * silently (`assertNoBodyContentClause`, backend/service/organize.ts). Asking it
+ * anyway is a 500, so the caller must not ask.
+ */
+export const isEvaluablePredicate = (
+	predicate: OrganizeMatchPredicate,
+): boolean =>
+	predicate.anchorMessageId !== undefined ||
+	!predicate.literalClauses.some((clause) => clause.field === "HasWords");
+
+/** What the count says when the predicate cannot be counted at all. */
+export const UNCOUNTABLE_PREDICATE_REASON =
+	"Can't count matches — “has the words” reads message bodies, which only a saved rule does.";
+
 /**
  * A stable key for a predicate's match set. Two predicates with the same key
  * match the same messages; a change to the key is what marks the live count

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

@@ -1,11 +1,8 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { isConvertible } from "@remit/ui";
 import { parseSearchTokens, type SearchTokenContext } from "../search-tokens";
-import {
-	buildSearchRule,
-	convertSearchToRule,
-	isConvertible,
-} from "./search-to-rule";
+import { convertSearchToRule } from "./search-to-rule";
 
 const CONTEXT: SearchTokenContext = {
 	mailboxesByName: new Map([["archive", "mbx-archive"]]),
@@ -114,33 +111,16 @@ describe("convertSearchToRule — semantic honesty (RFC 038 D5)", () => {
 	});
 });
 
-describe("isConvertible / buildSearchRule", () => {
-	it("is not convertible when the search yields no clause", () => {
+describe("convertSearchToRule — nothing left to make a filter from", () => {
+	it("yields no clause for a query of only dropped facets", () => {
 		assert.equal(isConvertible(convert("has:attachment")), false);
-		assert.equal(isConvertible(convert("in:archive")), false);
-	});
-
-	it("is convertible once a term or sender is present", () => {
-		assert.equal(isConvertible(convert("in:archive receipts")), true);
 	});
 
-	it("builds a standing rule with stable clause ids, no widen, empty name", () => {
-		const rule = buildSearchRule(convert("from:a@b.com 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("yields no clause for a bare folder scope", () => {
+		assert.equal(isConvertible(convert("in:archive")), false);
 	});
 
-	it("honors an explicit scope and move target", () => {
-		const rule = buildSearchRule(convert("nightly"), {
-			scope: "once",
-			moveMailboxId: "mbx-archive",
-		});
-		assert.equal(rule.scope, "once");
-		assert.equal(rule.moveMailboxId, "mbx-archive");
+	it("yields a clause once a term rides along with the folder scope", () => {
+		assert.equal(isConvertible(convert("in:archive receipts")), true);
 	});
 });

package/src/lib/organize/search-to-rule.ts

@@ -1,8 +1,7 @@
 import type {
-	ClauseField,
-	FilterRule,
-	MatchOperator,
-	RuleScope,
+	DroppedFacet,
+	DroppedFacetType,
+	SearchConversion,
 } from "@remit/ui";
 import {
 	type ParsedSearchQuery,
@@ -18,47 +17,13 @@ import {
  * The mapping is honest about what a filter cannot carry. A facet with no clause
  * equivalent is never silently folded into the rule: a folder scope is reported
  * as dropped-and-kept-out (the filter matches everywhere, not just there), the
- * attribute facets (attachment / unread / date) are reported as left out, and a
- * free-text query kept as a literal `HasWords` clause is reported as having lost
- * its semantic "similar mail" reach on a deployment that cannot embed the query
- * (D5). Pure functions only — the capability is injected, not probed here.
+ * attribute facets (attachment / read state / starred / category / date) are
+ * reported as left out, and a free-text query kept as a literal `HasWords` clause
+ * is reported as having lost its semantic "similar mail" reach on a deployment
+ * that cannot embed the query (D5). Pure functions only — the capability is
+ * injected, not probed here.
  */
 
-export interface DroppedFacet {
-	/** The facet that had no clause equivalent. */
-	type: SearchToken["type"];
-	/** 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;
-}
-
 interface ConvertOptions {
 	/**
 	 * Whether the current search surfaced semantically-similar mail (a non-empty
@@ -69,18 +34,28 @@ interface ConvertOptions {
 	searchHadSemanticReach: boolean;
 }
 
-const FACET_HAS_NO_CLAUSE: ReadonlySet<SearchToken["type"]> = new Set([
-	"hasAttachment",
-	"isUnread",
-	"before",
-	"after",
-]);
+type NoClauseFacet = Extract<SearchToken["type"], DroppedFacetType>;
+
+const FACET_HAS_NO_CLAUSE: ReadonlySet<SearchToken["type"]> =
+	new Set<NoClauseFacet>([
+		"hasAttachment",
+		"isUnread",
+		"isRead",
+		"isStarred",
+		"category",
+		"before",
+		"after",
+	]);
+
+const hasNoClauseEquivalent = (
+	type: SearchToken["type"],
+): type is NoClauseFacet => FACET_HAS_NO_CLAUSE.has(type);
 
 /**
  * Convert the current search into a rule's clauses and a record of what could not
- * be carried. Terms become a `HasWords` clause; a `from:` facet a `From` clause;
- * an `in:` facet a kept-out folder scope; `account:` the target account; the
- * attribute facets are dropped. The search's terms are ANDed with its facets, so
+ * be carried. Terms become a `HasWords` clause; a `from:` facet a `From` clause
+ * and a `subject:` facet a `Subject` clause; an `in:` facet a kept-out folder
+ * scope; `account:` the target account; the attribute facets are dropped. The search's terms are ANDed with its facets, so
  * the rule matches all of them (`all`).
  */
 export const convertSearchToRule = (
@@ -89,7 +64,7 @@ export const convertSearchToRule = (
 ): SearchConversion => {
 	const clauses: SearchConversion["clauses"] = [];
 	const droppedFacets: DroppedFacet[] = [];
-	let scopedOut: ScopedOutFolder | undefined;
+	let scopedOut: SearchConversion["scopedOut"];
 	let targetAccountId: string | undefined;
 
 	for (const token of parsed.tokens) {
@@ -97,6 +72,10 @@ export const convertSearchToRule = (
 			clauses.push({ field: "From", value: token.value });
 			continue;
 		}
+		if (token.type === "subject") {
+			clauses.push({ field: "Subject", value: token.value });
+			continue;
+		}
 		if (token.type === "in") {
 			scopedOut = { mailboxId: token.mailboxId, label: token.value };
 			continue;
@@ -105,7 +84,7 @@ export const convertSearchToRule = (
 			targetAccountId = token.accountId;
 			continue;
 		}
-		if (FACET_HAS_NO_CLAUSE.has(token.type)) {
+		if (hasNoClauseEquivalent(token.type)) {
 			droppedFacets.push({ type: token.type, label: searchTokenLabel(token) });
 		}
 	}
@@ -124,38 +103,3 @@ export const convertSearchToRule = (
 		droppedSemantic: keptTerms && searchHadSemanticReach,
 	};
 };
-
-/**
- * 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/organize/sender-fallback.test.ts

@@ -1,102 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import {
-	buildSenderFallbackDraft,
-	collapsibleDomain,
-	deriveSenderClauses,
-	distinctSenders,
-} from "./sender-fallback";
-
-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(["", "  "]), []);
-	});
-});
+import { buildSenderFallbackDraft } from "./sender-fallback";
 
 describe("buildSenderFallbackDraft", () => {
 	it("combines the sender clauses with Or and carries no anchor", () => {