@remit/ui 0.0.61 → 0.0.63

package/src/components/selection-wizard.render.test.ts

@@ -4,7 +4,10 @@ import { createElement } from "react";
 import { renderToString } from "react-dom/server";
 import type { MatchCount, StepId, WizardDraft } from "../lib/wizard-steps.js";
 import { stepsFor } from "../lib/wizard-steps.js";
-import type { RuleClause } from "./filter-rule.js";
+import {
+	type RuleClause,
+	UNCOUNTABLE_PREDICATE_REASON,
+} from "./filter-rule.js";
 import {
 	FolderStepBody,
 	MatchStepBody,
@@ -172,6 +175,23 @@ describe("SelectionSample", () => {
 		assert.match(html, /Nothing matches this yet/);
 	});
 
+	// A count that could not be taken is not a count of zero. A body-text clause
+	// is the case that makes the difference load-bearing: it matches, once a
+	// saved rule is what runs it, so "nothing matches this yet" is wrong rather
+	// than merely unexplained (#477 3.5).
+	it("says a count could not be taken instead of that nothing matched", () => {
+		const html = renderToString(
+			createElement(SelectionSample, {
+				messages: [],
+				count: { status: "error", reason: UNCOUNTABLE_PREDICATE_REASON },
+				label: "What this matches",
+				emptyReason: "noMatch",
+			}),
+		);
+		assert.match(text(html), /only a saved rule does/);
+		assert.doesNotMatch(html, /Nothing matches this yet/);
+	});
+
 	it("says the total is unknown when the match has not run", () => {
 		const html = renderToString(
 			createElement(SelectionSample, {
@@ -237,6 +257,36 @@ describe("MatchStepBody", () => {
 		assert.doesNotMatch(html, /disabled=""/);
 		assert.match(html, /matching on the\s+senders instead/);
 	});
+
+	it("names what an escalated predicate covers instead of offering doors", () => {
+		const html = renderToString(
+			createElement(MatchStepBody, {
+				...matchProps,
+				mode: "escalated",
+				escalatedScope: 'matching "npm"',
+				sample: {
+					messages,
+					count: counted(1284),
+					label: "A sample of what matches",
+				},
+			}),
+		);
+		assert.match(html, /Every message matching "npm"/);
+		assert.match(html, /nothing to widen/);
+		// The three doors are gone: a predicate is the match already.
+		assert.doesNotMatch(html, /These 2 messages/);
+		assert.doesNotMatch(html, /Similar to these/);
+		assert.doesNotMatch(html, /Its properties/);
+		// The members of the match still close the screen (#477 2.3).
+		assert.match(html, /Booking confirmation/);
+	});
+
+	it("falls back to naming the list rather than naming nothing", () => {
+		const html = renderToString(
+			createElement(MatchStepBody, { ...matchProps, mode: "escalated" }),
+		);
+		assert.match(html, /Every message the list is showing/);
+	});
 });
 
 describe("PropertiesStepBody", () => {
@@ -419,6 +469,29 @@ describe("ReviewStepBody", () => {
 		assert.match(html, /not known until the run finishes/);
 	});
 
+	it("states an escalated predicate and the count the server gave it", () => {
+		const html = renderToString(
+			createElement(ReviewStepBody, {
+				...reviewProps,
+				verb: "delete",
+				mode: "escalated",
+				escalatedScope: 'matching "npm"',
+				folder: undefined,
+				sample: {
+					messages,
+					count: counted(1284),
+					label: "A sample of what matches",
+				},
+			}),
+		);
+		assert.match(
+			text(html),
+			/Delete<\/span> all 1,284 messages matching &quot;npm&quot;/,
+		);
+		// The count is one reading of a live predicate, and the run takes another.
+		assert.match(html, /anything else matching by the time it runs/);
+	});
+
 	it("names the rule and its stop date once the scope persists", () => {
 		const html = renderToString(
 			createElement(ReviewStepBody, {
@@ -466,6 +539,23 @@ describe("RunStepBody", () => {
 		assert.match(html, /The rule itself is saved/);
 	});
 
+	it("says a stopped run was never sent rather than rejected", () => {
+		const html = renderToString(
+			createElement(RunStepBody, {
+				...runProps,
+				state: "runStopped",
+				scope: "once",
+				matched: 4,
+				applied: 2,
+				failures: messages,
+			}),
+		);
+		assert.match(html, /Stopped after 2/);
+		assert.match(html, /nothing was sent for them/);
+		assert.match(html, /Never sent/);
+		assert.doesNotMatch(html, /Server rejected/);
+	});
+
 	it("ends a one-off run on its own count", () => {
 		const html = renderToString(
 			createElement(RunStepBody, { ...runProps, scope: "once" }),
@@ -665,33 +755,35 @@ describe("SelectionWizard", () => {
 		assert.doesNotMatch(html, /<button[^>]*disabled=""/);
 	});
 
-	it("carries the blocked reason on the control before it is pressed, and shows it after", () => {
+	it("carries the blocked reason on the control before it is pressed, and announces it after", () => {
+		const reason = "Add a property to match on.";
 		const quiet = renderToString(
 			createElement(
 				SelectionWizard,
-				wizardProps({
-					step: "properties",
-					blockedReason: "Add a property to match on.",
-				}),
+				wizardProps({ step: "properties", blockedReason: reason }),
 			),
 		);
-		// Described, so it is heard on the control; not on screen until pressed.
+		// Described, so it is heard on the control; not on screen and nothing
+		// announced until the control is pressed.
 		assert.match(quiet, /aria-describedby="/);
-		assert.match(quiet, /sr-only/);
-		assert.doesNotMatch(quiet, /role="status"/);
+		assert.match(quiet, /<p id="[^"]*"[^>]*sr-only/);
+		assert.match(quiet, /role="status"[^>]*><\/span>/);
 
 		const nudged = renderToString(
 			createElement(
 				SelectionWizard,
 				wizardProps({
 					step: "properties",
-					blockedReason: "Add a property to match on.",
+					blockedReason: reason,
 					nudged: true,
 				}),
 			),
 		);
-		assert.match(nudged, /role="status"/);
-		assert.doesNotMatch(nudged, /sr-only/);
+		// The reason is written into the live region, which is what a screen
+		// reader announces — marking the description live would announce nothing.
+		assert.doesNotMatch(nudged, /role="status"[^>]*><\/span>/);
+		assert.match(nudged, new RegExp(`role="status"[^>]*>${reason}`));
+		assert.doesNotMatch(nudged, /<p id="[^"]*"[^>]*sr-only/);
 	});
 
 	it("commits under the scope's own label, in the verb's own tone", () => {

package/src/components/selection-wizard.tsx

@@ -21,7 +21,12 @@ import { Fragment, type ReactNode, useEffect, useId, useRef } from "react";
 import { cn } from "../lib/cn.js";
 import {
 	backExits,
+	ESCALATED_MATCH_HINT,
+	ESCALATED_REVIEW_WARNING,
+	ESCALATED_SCOPE_FALLBACK,
+	escalatedMatchLabel,
 	type MatchCount,
+	type MatchDoor,
 	type MatchMode,
 	matchDoorHint,
 	matchDoorLabel,
@@ -42,6 +47,7 @@ import {
 	type WizardDraft,
 } from "../lib/wizard-steps.js";
 import { Badge } from "./badge.js";
+import { BlockedReason } from "./blocked-reason.js";
 import { Button } from "./button.js";
 import { FieldLabel } from "./field-label.js";
 import {
@@ -279,6 +285,25 @@ const sampleFooter = (count: MatchCount, shown: number): string => {
 	return previewCountSummary(count);
 };
 
+/**
+ * What an empty sample says. A count that could not be taken says so; only a
+ * count that came back empty may say nothing matches (#477 3.5).
+ *
+ * A body-text clause is the case that makes the difference load-bearing: the
+ * vector-free matcher refuses to evaluate it, so there is no count and no rows,
+ * and "nothing matches this yet" is not merely unexplained but wrong — the rule
+ * matches, once a saved rule is what runs it.
+ */
+const sampleEmptyLine = (
+	count: MatchCount,
+	emptyReason: SampleEmptyReason | undefined,
+	loading: boolean | undefined,
+): string => {
+	if (loading) return "Fetching the messages this covers…";
+	if (count.status === "error") return count.reason;
+	return sampleEmptyCopy(emptyReason ?? "noMatch");
+};
+
 /**
  * The members of the match, closing every screen that names one. A named match
  * with no members shown is an unseen bulk action, so the rows scroll in their own
@@ -298,9 +323,7 @@ export function SelectionSample({
 			</h2>
 			{messages.length === 0 ? (
 				<p className="px-3 py-4 text-xs text-fg-muted">
-					{loading
-						? "Fetching the messages this covers…"
-						: sampleEmptyCopy(emptyReason ?? "noMatch")}
+					{sampleEmptyLine(count, emptyReason, loading)}
 				</p>
 			) : (
 				<>
@@ -345,9 +368,8 @@ export interface FooterNavProps {
 /**
  * Nothing disables (#477 1.7). A Continue with an answer still missing is dimmed
  * and stays pressable — and stays pressable to assistive technology too, which
- * `aria-disabled` would have taken away along with the reason. The reason is on
- * the control the whole time it applies, through `aria-describedby`; pressing it
- * is what brings the reason on screen.
+ * `aria-disabled` would have taken away along with the reason. `BlockedReason`
+ * carries the two ways that reason reaches the user.
  */
 export function FooterNav({
 	backLabel = "Back",
@@ -362,13 +384,12 @@ export function FooterNav({
 	return (
 		<div className="space-y-2">
 			{blockedReason && (
-				<p
+				<BlockedReason
 					id={reasonId}
-					role={nudged ? "status" : undefined}
-					className={cn("px-1 text-2xs text-warning", !nudged && "sr-only")}
-				>
-					{blockedReason}
-				</p>
+					reason={blockedReason}
+					nudged={nudged}
+					className="px-1 text-2xs text-warning"
+				/>
 			)}
 			<div className="flex items-center gap-3">
 				<Button
@@ -398,7 +419,12 @@ export function FooterNav({
 export interface MatchStepProps {
 	selectedCount: number;
 	mode: MatchMode;
-	onModeChange: (mode: MatchMode) => void;
+	/**
+	 * Answers the door. Typed to the three doors rather than to every mode, so
+	 * no driver can set `escalated` from a screen — the list escalates a
+	 * selection, the wizard never does.
+	 */
+	onModeChange: (mode: MatchDoor) => void;
 	/**
 	 * Similar-mail matching cannot run right now. A runtime state, not a property
 	 * of the deployment: the door stays pressable and dimmed.
@@ -413,6 +439,12 @@ export interface MatchStepProps {
 	/** The dimmed door was pressed and the senders were filled in instead. */
 	semanticFallbackTaken?: boolean;
 	onSemanticFallback: () => void;
+	/**
+	 * What the escalated predicate covers, in the words the list escalated it
+	 * with. Read only while the mode is `escalated`, where it replaces the three
+	 * doors: the predicate is the match already.
+	 */
+	escalatedScope?: string;
 	sample: SelectionSampleProps;
 }
 
@@ -424,8 +456,24 @@ export function MatchStepBody({
 	semanticErrorDetail,
 	semanticFallbackTaken,
 	onSemanticFallback,
+	escalatedScope,
 	sample,
 }: MatchStepProps) {
+	if (mode === "escalated") {
+		return (
+			<>
+				<div className="rounded-lg border border-accent bg-accent-soft p-3">
+					<p className="text-sm font-medium text-fg">
+						{escalatedMatchLabel(escalatedScope ?? ESCALATED_SCOPE_FALLBACK)}
+					</p>
+					<p className="mt-1 text-xs text-fg-muted">{ESCALATED_MATCH_HINT}</p>
+				</div>
+				<div className="mt-4">
+					<SelectionSample {...sample} />
+				</div>
+			</>
+		);
+	}
 	return (
 		<>
 			<div className="space-y-2">
@@ -805,6 +853,8 @@ export interface ReviewStepProps {
 	until?: string;
 	/** Present when the flow reached the naming step. */
 	ruleName?: string;
+	/** What the escalated predicate covers, in the list's own words. */
+	escalatedScope?: string;
 	sample: SelectionSampleProps;
 }
 
@@ -818,10 +868,21 @@ export function ReviewStepBody({
 	scope,
 	until,
 	ruleName,
+	escalatedScope,
 	sample,
 }: ReviewStepProps) {
 	const { label } = verbCopy(verb);
-	const description = { mode, selectedCount, clauses, matchOperator };
+	const description = {
+		mode,
+		selectedCount,
+		clauses,
+		matchOperator,
+		escalatedScope,
+		// A count still moving is not a number to commit against, and the footer
+		// under the review's Continue already says so.
+		escalatedCount:
+			sample.count.status === "ready" ? sample.count.count : undefined,
+	};
 	const widened = mode !== "selected";
 	const persists = scope === "standing" || scope === "until";
 
@@ -844,7 +905,9 @@ export function ReviewStepBody({
 				{widened && (
 					<p className="mt-2 flex items-start gap-1.5 text-xs text-warning">
 						<AlertTriangle className="mt-px size-3.5 shrink-0" />
-						This covers messages not shown in the list.
+						{mode === "escalated"
+							? ESCALATED_REVIEW_WARNING
+							: "This covers messages not shown in the list."}
 					</p>
 				)}
 			</div>
@@ -934,6 +997,9 @@ export function RunStepBody(props: RunStepProps) {
 	const { matched, applied, failures } = props;
 	const outcome = runOutcomeOf(props);
 	const copy = runCopy(outcome);
+	// A stopped run never sent these, so nothing rejected them.
+	const failureBadge =
+		props.state === "runStopped" ? "Never sent" : "Server rejected";
 
 	return (
 		<div className="space-y-4 pt-2">
@@ -964,7 +1030,7 @@ export function RunStepBody(props: RunStepProps) {
 									{message.subject}
 								</p>
 								<Badge className="mt-1" tone="warning">
-									Server rejected
+									{failureBadge}
 								</Badge>
 							</li>
 						))}
@@ -1132,10 +1198,17 @@ export function SelectionWizard(props: SelectionWizardProps) {
 		return runCopy(runOutcomeOf(stepProps(props.run, step))).screenTitle;
 	};
 
+	// An escalated predicate is offered no doors, so the screen states what it
+	// covers rather than asking a question with one answer.
+	const subtitle =
+		step === "match" && props.match?.mode === "escalated"
+			? "What this applies to"
+			: screen.subtitle;
+
 	return (
 		<WizardScreen
 			title={title()}
-			subtitle={screen.subtitle}
+			subtitle={subtitle}
 			steps={steps}
 			step={step}
 			onBack={onBack}

package/src/index.ts

@@ -67,6 +67,10 @@ export {
 	type BannerTone,
 	type BannerVariant,
 } from "./components/banner.js";
+export {
+	BlockedReason,
+	type BlockedReasonProps,
+} from "./components/blocked-reason.js";
 export {
 	BottomSheet,
 	type BottomSheetProps,
@@ -174,6 +178,7 @@ export {
 	type RuleWiden,
 	ruleBlockedCopy,
 	scopeLabel,
+	UNCOUNTABLE_PREDICATE_REASON,
 	unreadableBodyClauses,
 	widenChipLabel,
 } from "./components/filter-rule.js";
@@ -628,11 +633,11 @@ export {
 } from "./lib/roving-focus.js";
 export { type RuleNameParts, suggestRuleName } from "./lib/rule-name.js";
 export {
-	buildSearchRule,
 	type DroppedFacet,
 	type DroppedFacetType,
 	isConvertible,
 	type SearchConversion,
+	searchConversionNotice,
 } from "./lib/search-rule.js";
 export {
 	collapsibleDomain,
@@ -664,8 +669,13 @@ export {
 	clauseWords,
 	crossAccountDestinationReason,
 	crossAccountRuleReason,
+	ESCALATED_MATCH_HINT,
+	ESCALATED_REVIEW_WARNING,
+	ESCALATED_SCOPE_FALLBACK,
+	escalatedMatchLabel,
 	type MatchCount,
 	type MatchDescription,
+	type MatchDoor,
 	type MatchMode,
 	matchDoorHint,
 	matchDoorLabel,

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

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
-	buildSearchRule,
 	isConvertible,
 	type SearchConversion,
+	searchConversionNotice,
 } from "./search-rule.js";
 
 const conversion = (
@@ -43,31 +43,32 @@ describe("isConvertible", () => {
 	});
 });
 
-describe("buildSearchRule", () => {
-	it("builds a standing rule with stable clause ids, no widen, empty name", () => {
-		const rule = buildSearchRule(
+describe("searchConversionNotice", () => {
+	it("names the folder the search was scoped to and every facet dropped", () => {
+		const notice = searchConversionNotice(
 			conversion({
-				clauses: [
-					{ field: "From", value: "a@b.com" },
-					{ field: "HasWords", value: "nightly" },
-				],
+				clauses: [{ field: "HasWords", value: "npm" }],
+				keptTerms: true,
+				scopedOut: { mailboxId: "mbx-archive", label: "Archive" },
+				droppedFacets: [{ type: "isUnread", label: "Unread" }],
+				droppedSemantic: true,
 			}),
 		);
-		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"],
-		);
+		assert.deepEqual(notice, {
+			scopedOutFolder: "Archive",
+			droppedFacets: ["Unread"],
+			droppedSemantic: true,
+		});
 	});
 
-	it("honors an explicit scope and move target", () => {
-		const rule = buildSearchRule(
-			conversion({ clauses: [{ field: "HasWords", value: "nightly" }] }),
-			{ scope: "once", moveMailboxId: "mbx-archive" },
+	it("states nothing for a conversion that carried everything", () => {
+		const notice = searchConversionNotice(
+			conversion({ clauses: [{ field: "From", value: "a@b.com" }] }),
 		);
-		assert.equal(rule.scope, "once");
-		assert.equal(rule.moveMailboxId, "mbx-archive");
+		assert.deepEqual(notice, {
+			scopedOutFolder: undefined,
+			droppedFacets: [],
+			droppedSemantic: false,
+		});
 	});
 });

package/src/lib/search-rule.ts

@@ -1,16 +1,12 @@
 /**
- * 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.
+ * What a search converts to (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";
+import type { ClauseField, MatchOperator } from "../components/filter-rule.js";
+import type { SearchConversionNotice } from "../components/search-conversion.js";
 
 /**
  * A search facet a filter has no clause for. Attachment, read state, starred,
@@ -68,29 +64,15 @@ export interface SearchConversion {
 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).
+ * The conversion as the notice reads it. One mapping, beside both shapes, so
+ * every surface that opens on a converted search states the same losses in the
+ * same words.
  */
-export const buildSearchRule = (
+export const searchConversionNotice = (
 	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: "",
+): SearchConversionNotice => ({
+	scopedOutFolder: conversion.scopedOut?.label,
+	droppedFacets: conversion.droppedFacets.map((facet) => facet.label),
+	droppedSemantic: conversion.droppedSemantic,
 });

package/src/lib/wizard-steps.test.ts

@@ -9,6 +9,9 @@ import {
 	backExits,
 	clauseSentence,
 	clauseWords,
+	ESCALATED_MATCH_HINT,
+	ESCALATED_REVIEW_WARNING,
+	escalatedMatchLabel,
 	type MatchCount,
 	type MatchMode,
 	matchDoorHint,
@@ -30,7 +33,7 @@ import {
 } from "./wizard-steps.js";
 
 const VERBS: Verb[] = ["delete", "move", "junk", "markRead", "organize"];
-const MODES: MatchMode[] = ["selected", "similar", "properties"];
+const MODES: MatchMode[] = ["selected", "similar", "properties", "escalated"];
 const SCOPES: (RuleScope | undefined)[] = [
 	undefined,
 	"once",
@@ -475,6 +478,7 @@ describe("runCopy", () => {
 			"backApplyFailed",
 			"backApplyStartFailed",
 			"filterSaved",
+			"runStopped",
 			"commitFailed",
 		];
 		for (const state of states) {
@@ -499,6 +503,23 @@ describe("runCopy", () => {
 		assert.doesNotMatch(once.detail, /rule/);
 	});
 
+	it("separates a run that stopped from a pass the server rejected", () => {
+		// The bulk endpoints accept every id in a call that returns, so the only
+		// failure the chunked runner can observe is a call that threw — and
+		// everything after it was never sent. Saying the mail server rejected
+		// those states a cause that did not happen.
+		const stopped = outcome("runStopped", "once");
+		assert.equal(stopped.title, "Stopped after 10");
+		assert.match(stopped.detail, /nothing was sent for them/);
+		assert.doesNotMatch(stopped.detail, /rejected/);
+		assert.equal(stopped.retryLabel, "Retry 2");
+		assert.equal(stopped.showProgress, true);
+
+		// The back-apply pass is run by the server, which reports what it could
+		// not apply — a rejection, and worded as one.
+		assert.match(outcome("backApplyFailed", "once").detail, /rejected/);
+	});
+
 	it("ends a one-off run on its own count and a saved rule on the rule", () => {
 		assert.equal(outcome("backApplyComplete", "once").title, "Moved 10");
 		assert.equal(
@@ -585,6 +606,15 @@ describe("sample and door vocabulary", () => {
 		assert.match(sampleEmptyCopy("notIndexed"), /isn't indexed yet/);
 	});
 
+	it("states what an escalated predicate covers instead of a door", () => {
+		assert.equal(
+			escalatedMatchLabel('matching "npm"'),
+			'Every message matching "npm"',
+		);
+		assert.match(ESCALATED_MATCH_HINT, /nothing to widen/);
+		assert.match(ESCALATED_REVIEW_WARNING, /by the time it runs/);
+	});
+
 	it("names each door and what it does", () => {
 		assert.equal(matchDoorLabel("selected", 3), "These 3 messages");
 		assert.equal(matchDoorLabel("similar", 3), "Similar to these 3");
@@ -661,6 +691,55 @@ describe("the match as words", () => {
 		);
 	});
 
+	it("summarises an escalated predicate by what it covers", () => {
+		assert.equal(
+			matchSummary({
+				mode: "escalated",
+				selectedCount: 4,
+				clauses,
+				matchOperator: "all",
+				escalatedScope: 'matching "npm"',
+			}),
+			'Every message matching "npm"',
+		);
+		assert.equal(
+			matchSummary({
+				mode: "escalated",
+				selectedCount: 4,
+				clauses,
+				matchOperator: "all",
+			}),
+			"Every message the list is showing",
+		);
+	});
+
+	it("phrases an escalated predicate with the count the server gave it", () => {
+		assert.equal(
+			matchPhrase({
+				mode: "escalated",
+				selectedCount: 4,
+				clauses,
+				matchOperator: "all",
+				escalatedScope: 'matching "npm"',
+				escalatedCount: 3412,
+			}),
+			'all 3,412 messages matching "npm"',
+		);
+	});
+
+	it("claims no number while the count is still being taken", () => {
+		assert.equal(
+			matchPhrase({
+				mode: "escalated",
+				selectedCount: 4,
+				clauses,
+				matchOperator: "all",
+				escalatedScope: 'matching "npm"',
+			}),
+			'every message matching "npm"',
+		);
+	});
+
 	it("phrases each door for the review sentence", () => {
 		assert.equal(
 			matchPhrase({