@remit/web-client 0.0.87 → 0.0.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "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/MailListHeader.tsx

@@ -40,6 +40,7 @@
  */
 import {
 	type FilterSheetProps,
+	isConvertible,
 	MailHeader,
 	MakeFilterAction,
 	MobileSearchView,
@@ -68,10 +69,7 @@ import { useSearchScope } from "@/hooks/useSearchScope";
 import { useSearchSuggestions } from "@/hooks/useSearchSuggestions";
 import { useSearchTokenContext } from "@/hooks/useSearchTokenContext";
 import { useMailContext } from "@/lib/mail-context";
-import {
-	convertSearchToRule,
-	isConvertible,
-} from "@/lib/organize/search-to-rule";
+import { convertSearchToRule } from "@/lib/organize/search-to-rule";
 import { loadRecentSearches, saveRecentSearch } from "@/lib/recent-searches";
 import { resultsScopeForRoute, routeMailboxId } from "@/lib/search-scope";
 import { applySearchSuggestion } from "@/lib/search-suggestions";

package/src/components/mail/organize/SearchFilterDialog.tsx

@@ -1,12 +1,9 @@
-import { Button, Dialog } from "@remit/ui";
+import { Button, buildSearchRule, Dialog } from "@remit/ui";
 import { Loader2 } from "lucide-react";
 import { useMemo } from "react";
 import { useSearchFilterSeed } from "@/hooks/useSearchFilterSeed";
 import { rulePredicate } from "@/lib/organize/rule-model";
-import {
-	buildSearchRule,
-	convertSearchToRule,
-} from "@/lib/organize/search-to-rule";
+import { convertSearchToRule } from "@/lib/organize/search-to-rule";
 import type { ParsedSearchQuery } from "@/lib/search-tokens";
 import { SearchFilterEditor } from "./SearchFilterEditor";
 

package/src/components/mail/organize/SearchFilterEditor.tsx

@@ -1,8 +1,10 @@
 import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import {
+	buildSearchRule,
 	type FilterRule,
 	FilterRuleEditor,
 	type FolderOption,
+	type SearchConversion,
 	SearchConversionNoticeView,
 } from "@remit/ui";
 import { useQuery } from "@tanstack/react-query";
@@ -18,10 +20,6 @@ import {
 	ruleToDraft,
 	SUPPORTED_CLAUSE_FIELDS,
 } from "@/lib/organize/rule-model";
-import {
-	buildSearchRule,
-	type SearchConversion,
-} from "@/lib/organize/search-to-rule";
 import {
 	CommitError,
 	FilterSaved,

package/src/hooks/useOrganizeWiden.ts

@@ -1,11 +1,10 @@
 import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { deriveSenderClauses, distinctSenders } from "@remit/ui";
 import { useMutation } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildOrganizeInput } from "@/lib/organize/organize-model";
 import {
 	buildSenderFallbackDraft,
-	deriveSenderClauses,
-	distinctSenders,
 	type OrganizeMatchPredicate,
 } from "@/lib/organize/sender-fallback";
 

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

@@ -1,5 +1,4 @@
-import type { ClauseField, Suggestion } from "@remit/ui";
-import { senderDomain } from "./sender-fallback";
+import { type ClauseField, type Suggestion, senderDomain } from "@remit/ui";
 
 /**
  * Values worth offering while a clause is being typed. The rule editor's value

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

@@ -1,15 +1,15 @@
-import type {
-	ClauseField,
-	FilterRule,
-	MatchOperator,
-	PreviewCount,
-	RuleClause,
-	RuleMatchMode,
-	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 { derivePropertyClauses } from "./property-prefill";
 import type { OrganizeMatchPredicate } from "./sender-fallback";
 
 /**

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,
@@ -19,47 +18,12 @@ import {
  * 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 / 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.
+ * 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
@@ -70,15 +34,22 @@ interface ConvertOptions {
 	searchHadSemanticReach: boolean;
 }
 
-const FACET_HAS_NO_CLAUSE: ReadonlySet<SearchToken["type"]> = new Set([
-	"hasAttachment",
-	"isUnread",
-	"isRead",
-	"isStarred",
-	"category",
-	"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
@@ -93,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) {
@@ -113,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) });
 		}
 	}
@@ -132,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", () => {

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

@@ -1,93 +1,20 @@
-import type {
-	RemitImapFilterClause,
-	RemitImapOrganizeInput,
-} from "@remit/api-http-client/types.gen.ts";
-import { getDomain } from "tldts";
+import type { RemitImapOrganizeInput } from "@remit/api-http-client/types.gen.ts";
+import { deriveSenderClauses } 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: one `From` clause per distinct sender in the selection, 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.
- */
-
-/**
- * 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.
+ * 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.
  */
-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[],
-): 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`
- * 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 sender
+ * clauses 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[],

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

@@ -1,173 +0,0 @@
-/**
- * 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";
-
-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/organize/property-prefill.ts

@@ -1,151 +0,0 @@
-import type { RemitImapFilterClause } from "@remit/api-http-client/types.gen.ts";
-import { deriveSenderClauses, distinctSenders } from "./sender-fallback";
-
-/**
- * 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-fallback 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[],
-): RemitImapFilterClause[] => {
-	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 widen fallback's own derivation (#251).
-	return senderClauses;
-};