@remit/web-client 0.0.321 → 0.0.323

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

@@ -9,7 +9,6 @@ import { describe, it } from "node:test";
 import type { FilterRule } from "@remit/ui";
 import { buildOrganizeInput } from "./organize-model";
 import {
-	buildInitialRule,
 	derivePreview,
 	isEvaluablePredicate,
 	normalizeClauseValue,
@@ -17,21 +16,8 @@ import {
 	predicateSignature,
 	rulePredicate,
 	ruleToDraft,
-	SUPPORTED_CLAUSE_FIELDS,
 } from "./rule-model";
 
-describe("SUPPORTED_CLAUSE_FIELDS", () => {
-	it("offers every field the backend matcher now evaluates, ListId and FromDomain included (#262)", () => {
-		assert.deepEqual(SUPPORTED_CLAUSE_FIELDS, [
-			"From",
-			"Subject",
-			"HasWords",
-			"ListId",
-			"FromDomain",
-		]);
-	});
-});
-
 describe("normalizeListId", () => {
 	it("strips the bracketed identifier, trims, and case-folds — matching the backend", () => {
 		assert.equal(
@@ -55,121 +41,24 @@ describe("normalizeListId", () => {
 	});
 });
 
-describe("buildInitialRule", () => {
-	it("opens a semantic-capable rule on the widen anchor with no literal clauses", () => {
-		const rule = buildInitialRule({
-			anchorMessageId: "msg-1",
-			semanticUnavailable: false,
-			senders: [],
-			selectionCount: 3,
-		});
-		assert.equal(rule.clauses.length, 0);
-		assert.deepEqual(rule.widen, { anchorCount: 3 });
-		assert.equal(rule.matchOperator, "all");
-		assert.equal(rule.scope, "once");
-	});
-
-	it("opens the sender fallback on visible, editable derived From chips (#251)", () => {
-		const rule = buildInitialRule({
-			anchorMessageId: "msg-1",
-			semanticUnavailable: true,
-			senders: ["a@x.com", "b@y.com"],
-			selectionCount: 2,
-		});
-		assert.equal(rule.widen, undefined);
-		assert.equal(rule.matchOperator, "any");
-		assert.deepEqual(
-			rule.clauses.map((clause) => ({
-				field: clause.field,
-				value: clause.value,
-				derived: clause.derived,
-			})),
-			[
-				{ field: "From", value: "a@x.com", derived: true },
-				{ field: "From", value: "b@y.com", derived: true },
-			],
-		);
-	});
-
-	it("collapses senders sharing a registrable domain to one derived FromDomain chip (#262)", () => {
-		const rule = buildInitialRule({
-			semanticUnavailable: true,
-			senders: ["npm@github.com", "ci@sub.github.com"],
-			selectionCount: 2,
-		});
-		assert.equal(rule.matchOperator, "any");
-		assert.deepEqual(
-			rule.clauses.map((clause) => ({
-				field: clause.field,
-				value: clause.value,
-				derived: clause.derived,
-			})),
-			[{ field: "FromDomain", value: "github.com", derived: true }],
-		);
-	});
-
-	it("carries a Something-else seed's folder and scope", () => {
-		const rule = buildInitialRule({
-			anchorMessageId: "msg-1",
-			semanticUnavailable: false,
-			senders: [],
-			selectionCount: 1,
-			seedMailboxId: "mbx-archive",
-			seedScope: "standing",
-		});
-		assert.equal(rule.moveMailboxId, "mbx-archive");
-		assert.equal(rule.scope, "standing");
-	});
-
-	it("offers no widen when there is no anchor to ride on", () => {
-		const rule = buildInitialRule({
-			semanticUnavailable: false,
-			senders: [],
-			selectionCount: 0,
-		});
-		assert.equal(rule.widen, undefined);
-	});
-});
-
-const semanticRule: FilterRule = {
+const rule: FilterRule = {
 	clauses: [{ id: "c1", field: "Subject", value: "receipt" }],
 	matchOperator: "all",
-	widen: { anchorCount: 2 },
 	moveMailboxId: "mbx-archive",
 	scope: "once",
 };
 
 describe("rulePredicate", () => {
-	it("includes the anchor while the widen is present and active", () => {
-		const predicate = rulePredicate(semanticRule, "msg-1");
-		assert.equal(predicate.anchorMessageId, "msg-1");
+	it("carries the operator and the literal clauses", () => {
+		const predicate = rulePredicate(rule);
 		assert.equal(predicate.matchOperator, "And");
 		assert.deepEqual(predicate.literalClauses, [
 			{ field: "Subject", value: "receipt" },
 		]);
 	});
 
-	it("drops the anchor once the widen is removed", () => {
-		const predicate = rulePredicate(
-			{ ...semanticRule, widen: undefined },
-			"msg-1",
-		);
-		assert.equal(predicate.anchorMessageId, undefined);
-	});
-
-	it("drops the anchor for a widen the deployment cannot evaluate (D4 inactive)", () => {
-		const predicate = rulePredicate(
-			{ ...semanticRule, widen: { anchorCount: 2, inactive: true } },
-			"msg-1",
-		);
-		assert.equal(predicate.anchorMessageId, undefined);
-	});
-
 	it("maps the any operator to Or", () => {
-		const predicate = rulePredicate(
-			{ ...semanticRule, matchOperator: "any" },
-			"msg-1",
-		);
+		const predicate = rulePredicate({ ...rule, matchOperator: "any" });
 		assert.equal(predicate.matchOperator, "Or");
 	});
 });
@@ -177,28 +66,19 @@ describe("rulePredicate", () => {
 describe("predicateSignature", () => {
 	it("is stable across identical predicates", () => {
 		assert.equal(
-			predicateSignature(rulePredicate(semanticRule, "msg-1")),
-			predicateSignature(rulePredicate(semanticRule, "msg-1")),
+			predicateSignature(rulePredicate(rule)),
+			predicateSignature(rulePredicate(rule)),
 		);
 	});
 
 	it("changes when a clause value changes", () => {
 		const changed: FilterRule = {
-			...semanticRule,
+			...rule,
 			clauses: [{ id: "c1", field: "Subject", value: "invoice" }],
 		};
 		assert.notEqual(
-			predicateSignature(rulePredicate(semanticRule, "msg-1")),
-			predicateSignature(rulePredicate(changed, "msg-1")),
-		);
-	});
-
-	it("changes when the widen is removed", () => {
-		assert.notEqual(
-			predicateSignature(rulePredicate(semanticRule, "msg-1")),
-			predicateSignature(
-				rulePredicate({ ...semanticRule, widen: undefined }, "msg-1"),
-			),
+			predicateSignature(rulePredicate(rule)),
+			predicateSignature(rulePredicate(changed)),
 		);
 	});
 });
@@ -206,52 +86,35 @@ describe("predicateSignature", () => {
 describe("the previewed set equals the applied set", () => {
 	it("carries exactly the previewed predicate into the commit draft", () => {
 		const preview = buildOrganizeInput({
-			...rulePredicate(semanticRule, "msg-1"),
-			matchOperator: rulePredicate(semanticRule, "msg-1").matchOperator,
-			literalClauses: rulePredicate(semanticRule, "msg-1").literalClauses,
+			...rulePredicate(rule),
+			matchOperator: rulePredicate(rule).matchOperator,
+			literalClauses: rulePredicate(rule).literalClauses,
 		});
-		const apply = buildOrganizeInput(ruleToDraft(semanticRule, "msg-1"));
-		assert.equal(apply.anchorMessageId, preview.anchorMessageId);
+		const apply = buildOrganizeInput(ruleToDraft(rule));
 		assert.equal(apply.matchOperator, preview.matchOperator);
 		assert.deepEqual(apply.literalClauses, preview.literalClauses);
 	});
 
-	it("keeps them equal for the sender fallback (no anchor, Or)", () => {
-		const rule = buildInitialRule({
-			semanticUnavailable: true,
-			senders: ["a@x.com", "b@y.com"],
-			selectionCount: 2,
-		});
-		const predicate = rulePredicate(rule);
-		const apply = buildOrganizeInput(ruleToDraft(rule));
-		assert.equal(apply.anchorMessageId, undefined);
-		assert.equal(apply.matchOperator, "Or");
-		assert.deepEqual(apply.literalClauses, predicate.literalClauses);
-	});
-
 	it("adds the expiry only for the until scope, never touching the match set", () => {
-		const once = ruleToDraft(semanticRule, "msg-1");
+		const once = ruleToDraft(rule);
 		assert.equal(once.expiresAt, undefined);
 
-		const until = ruleToDraft(
-			{ ...semanticRule, scope: "until", until: "2999-01-02" },
-			"msg-1",
-		);
+		const until = ruleToDraft({
+			...rule,
+			scope: "until",
+			until: "2999-01-02",
+		});
 		assert.ok(until.expiresAt?.startsWith("2999-01-02"));
 		assert.deepEqual(until.literalClauses, once.literalClauses);
-		assert.equal(until.anchorMessageId, once.anchorMessageId);
 	});
 
 	it("carries the move destination into the draft", () => {
-		assert.equal(
-			ruleToDraft(semanticRule, "msg-1").moveMailboxId,
-			"mbx-archive",
-		);
+		assert.equal(ruleToDraft(rule).moveMailboxId, "mbx-archive");
 	});
 
 	it("carries the label target into the draft (issue #26)", () => {
-		const labeled = { ...semanticRule, labelId: "lbl-receipts" };
-		assert.equal(ruleToDraft(labeled, "msg-1").labelId, "lbl-receipts");
+		const labeled = { ...rule, labelId: "lbl-receipts" };
+		assert.equal(ruleToDraft(labeled).labelId, "lbl-receipts");
 	});
 });
 
@@ -276,36 +139,6 @@ describe("derivePreview", () => {
 		);
 	});
 
-	it("carries the empty-index answer through, so a zero can say why (#452)", () => {
-		assert.deepEqual(
-			derivePreview(
-				{ count: 0, indexEmpty: true, previewedSignature: signature },
-				signature,
-			),
-			{ status: "ready", count: 0, indexEmpty: true },
-		);
-	});
-
-	it("keeps the empty-index answer on a stale count", () => {
-		assert.deepEqual(
-			derivePreview(
-				{ count: 0, indexEmpty: true, previewedSignature: "sig-old" },
-				signature,
-			),
-			{ status: "ready", count: 0, stale: true, indexEmpty: true },
-		);
-	});
-
-	it("leaves the flag off when the index answered", () => {
-		assert.deepEqual(
-			derivePreview(
-				{ count: 0, indexEmpty: false, previewedSignature: signature },
-				signature,
-			),
-			{ status: "ready", count: 0 },
-		);
-	});
-
 	it("surfaces an error raised for the current predicate", () => {
 		assert.deepEqual(
 			derivePreview(
@@ -333,7 +166,7 @@ describe("derivePreview", () => {
 });
 
 describe("isEvaluablePredicate", () => {
-	it("accepts literal clauses the vector-free matcher can read off the index", () => {
+	it("accepts literal clauses the matcher can read off the thread rows", () => {
 		assert.equal(
 			isEvaluablePredicate({
 				matchOperator: "And",
@@ -346,7 +179,7 @@ describe("isEvaluablePredicate", () => {
 		);
 	});
 
-	it("rejects a body clause with no anchor — the shape that answered 500", () => {
+	it("rejects a body clause — the shape that answered 500", () => {
 		assert.equal(
 			isEvaluablePredicate({
 				matchOperator: "And",
@@ -369,17 +202,6 @@ describe("isEvaluablePredicate", () => {
 		);
 	});
 
-	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: [] }),

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

@@ -1,16 +1,11 @@
-import {
-	type ClauseField,
-	derivePropertyClauses,
-	type FilterRule,
-	type MatchOperator,
-	type PreviewCount,
-	type RuleClause,
-	type RuleMatchMode,
-	type RuleScope,
+import type {
+	ClauseField,
+	FilterRule,
+	MatchOperator,
+	PreviewCount,
 } from "@remit/ui";
 import { pickedDateToExpiresAt } from "./filter-status";
-import type { OrganizeDraft } from "./organize-model";
-import type { OrganizeMatchPredicate } from "./sender-fallback";
+import type { OrganizeDraft, OrganizeMatchPredicate } from "./organize-model";
 
 /**
  * The clause fields the Organize editor may offer (RFC 038 D2). Gated on what
@@ -49,163 +44,31 @@ export const normalizeClauseValue = (
 const toApiOperator = (operator: MatchOperator): "And" | "Or" =>
 	operator === "all" ? "And" : "Or";
 
-export interface InitialRuleInput {
-	/** The semantic anchor — the first selected message. */
-	anchorMessageId?: string;
-	/**
-	 * The deployment ships no vector pipeline, so the widen cannot run. The rule
-	 * opens on the property-derived literal clauses instead of an anchor.
-	 */
-	semanticUnavailable: boolean;
-	/**
-	 * 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. */
-	seedMailboxId?: string;
-	/** A scope a "Something else" shortcut pre-picked. */
-	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;
-}
-
-/**
- * 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 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: [...kept, ...prefill],
-			matchOperator: kept.length > 0 ? (input.currentOperator ?? "any") : "any",
-			widen: undefined,
-		};
-	}
-	return {
-		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: "",
-	};
-};
-
-/**
- * The match-relevant projection of a rule — the anchor (only while the widen is
- * present and active), the operator, and the literal clauses. Preview and apply
+ * The match-relevant projection of a rule — the operator and the literal
+ * clauses. Preview and apply
  * both derive from this, so the set the editor counts is the set a commit acts
  * on. Fields that do not change the match set (folder, scope, name, date) are
  * deliberately absent.
  */
-export const rulePredicate = (
-	rule: FilterRule,
-	anchorMessageId?: string,
-): OrganizeMatchPredicate => {
-	const widenActive = rule.widen !== undefined && !rule.widen.inactive;
-	const literalClauses = rule.clauses.map((clause) => ({
+export const rulePredicate = (rule: FilterRule): OrganizeMatchPredicate => ({
+	matchOperator: toApiOperator(rule.matchOperator),
+	literalClauses: rule.clauses.map((clause) => ({
 		field: clause.field,
 		value: clause.value,
-	}));
-	return {
-		...(widenActive && anchorMessageId ? { anchorMessageId } : {}),
-		matchOperator: toApiOperator(rule.matchOperator),
-		literalClauses,
-	};
-};
+	})),
+});
 
 /**
  * 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 (`bodyContentRejection`, backend/service/organize.ts). Asking it
+ * all. It reads no message body and rejects a `HasWords` clause rather than
+ * narrowing the match silently (`bodyContentRejection`, backend/service/organize.ts). Asking it
  * anyway is refused with a 400, on preview and on a back-apply alike, so the
  * caller must not ask.
  */
 export const isEvaluablePredicate = (
 	predicate: OrganizeMatchPredicate,
 ): boolean =>
-	predicate.anchorMessageId !== undefined ||
 	!predicate.literalClauses.some((clause) => clause.field === "HasWords");
 
 /**
@@ -215,7 +78,6 @@ export const isEvaluablePredicate = (
  */
 export const predicateSignature = (predicate: OrganizeMatchPredicate): string =>
 	JSON.stringify({
-		anchor: predicate.anchorMessageId ?? null,
 		operator: predicate.matchOperator,
 		clauses: predicate.literalClauses.map(
 			(clause) => `${clause.field} ${clause.value}`,
@@ -228,15 +90,9 @@ export const predicateSignature = (predicate: OrganizeMatchPredicate): string =>
  * and, for the `until` scope, the derived expiry added. The expiry never enters
  * the match set, so preview and apply still count and act on the same messages.
  */
-export const ruleToDraft = (
-	rule: FilterRule,
-	anchorMessageId?: string,
-): OrganizeDraft => {
-	const predicate = rulePredicate(rule, anchorMessageId);
+export const ruleToDraft = (rule: FilterRule): OrganizeDraft => {
+	const predicate = rulePredicate(rule);
 	return {
-		...(predicate.anchorMessageId
-			? { anchorMessageId: predicate.anchorMessageId }
-			: {}),
 		matchOperator: predicate.matchOperator,
 		literalClauses: predicate.literalClauses,
 		moveMailboxId: rule.moveMailboxId,
@@ -253,8 +109,6 @@ export interface PreviewState {
 	count?: number;
 	/** The ids that count was counted over, as the server bounded them. */
 	matchedIds?: readonly string[];
-	/** The server said the semantic index had nothing to answer with (#452). */
-	indexEmpty?: boolean;
 	/** The signature the {@link count} was counted for. */
 	previewedSignature?: string;
 	/** The signature the last error was raised for. */
@@ -276,11 +130,10 @@ export const derivePreview = (
 		return { status: "error", reason: state.error };
 	}
 	if (state.count === undefined) return { status: "loading" };
-	const indexEmpty = state.indexEmpty === true ? { indexEmpty: true } : {};
 	if (state.previewedSignature === currentSignature) {
-		return { status: "ready", count: state.count, ...indexEmpty };
+		return { status: "ready", count: state.count };
 	}
-	return { status: "ready", count: state.count, stale: true, ...indexEmpty };
+	return { status: "ready", count: state.count, stale: true };
 };
 
 /** How long a rule change settles before the next preview fires. */

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

@@ -9,13 +9,8 @@ const CONTEXT: SearchTokenContext = {
 	accountsByName: new Map([["work", "acc-work"]]),
 };
 
-const convert = (
-	query: string,
-	options: { searchHadSemanticReach?: boolean } = {},
-) =>
-	convertSearchToRule(parseSearchTokens(query, CONTEXT), {
-		searchHadSemanticReach: options.searchHadSemanticReach ?? false,
-	});
+const convert = (query: string) =>
+	convertSearchToRule(parseSearchTokens(query, CONTEXT));
 
 describe("convertSearchToRule — facet → clause mapping", () => {
 	it("maps literal terms to a HasWords clause", () => {
@@ -82,35 +77,6 @@ describe("convertSearchToRule — facets with no clause equivalent", () => {
 	});
 });
 
-describe("convertSearchToRule — semantic honesty (RFC 038 D5)", () => {
-	it("states the dropped reach when the search surfaced similar mail", () => {
-		// The literal filter cannot reproduce the reach the search just showed.
-		const conversion = convert("things like this", {
-			searchHadSemanticReach: true,
-		});
-		assert.equal(conversion.droppedSemantic, true);
-		// The literal words are still kept.
-		assert.deepEqual(conversion.clauses, [
-			{ field: "HasWords", value: "things like this" },
-		]);
-	});
-
-	it("says nothing when the search had no semantic reach to drop", () => {
-		const conversion = convert("things like this", {
-			searchHadSemanticReach: false,
-		});
-		assert.equal(conversion.droppedSemantic, false);
-	});
-
-	it("never reports dropped semantics for a facet-only search", () => {
-		const conversion = convert("from:a@b.com", {
-			searchHadSemanticReach: true,
-		});
-		assert.equal(conversion.keptTerms, false);
-		assert.equal(conversion.droppedSemantic, false);
-	});
-});
-
 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);

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

@@ -19,22 +19,9 @@ 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. Pure functions only.
  */
 
-interface ConvertOptions {
-	/**
-	 * Whether the current search surfaced semantically-similar mail (a non-empty
-	 * "Related" section). This is the reach the literal filter cannot reproduce —
-	 * the direct existing signal, read from the search's own semantic results, not
-	 * a probe of deployment capability.
-	 */
-	searchHadSemanticReach: boolean;
-}
-
 type NoClauseFacet = Extract<SearchToken["type"], DroppedFacetType>;
 
 const FACET_HAS_NO_CLAUSE: ReadonlySet<SearchToken["type"]> =
@@ -61,7 +48,6 @@ const hasNoClauseEquivalent = (
  */
 export const convertSearchToRule = (
 	parsed: ParsedSearchQuery,
-	{ searchHadSemanticReach }: ConvertOptions,
 ): SearchConversion => {
 	const clauses: SearchConversion["clauses"] = [];
 	const droppedFacets: DroppedFacet[] = [];
@@ -101,7 +87,6 @@ export const convertSearchToRule = (
 		droppedFacets,
 		targetAccountId,
 		keptTerms,
-		droppedSemantic: keptTerms && searchHadSemanticReach,
 	};
 };