@remit/web-client 0.0.92 → 0.0.94

package/src/components/mail/ThreadListInteraction.tsx

@@ -36,7 +36,6 @@ import type { TriageContextUpdate } from "@/hooks/useTriageLayer";
 import { formatDeleteToTrashTitle } from "@/lib/format";
 import { tabStopId } from "@/lib/list-focus";
 import { useListHeaderChrome } from "@/lib/list-header-chrome";
-import { useMailContext } from "@/lib/mail-context";
 import type { MessageListCommands } from "./MessageList";
 import type { MessageRowSelection } from "./MessageRow";
 
@@ -187,14 +186,6 @@ export function ThreadListInteraction({
 		if (orderedIds.length > 0) toggleAll(orderedIds);
 	}, [orderedIds, toggleAll]);
 
-	// The selection wizard is mounted on the route, above this provider, and
-	// acts on these rows — so it reads the count from here rather than keeping
-	// one of its own (#477).
-	const { onSelectedCountChange } = useMailContext();
-	useEffect(() => {
-		onSelectedCountChange(selectedCount);
-	}, [selectedCount, onSelectedCountChange]);
-
 	// A row that leaves the list — a chip filter, a collapsed section, a
 	// completed delete — cannot stay selected. Survivors keep their selection.
 	const { intersectWith } = selection;

package/src/components/mail/make-filter-entry.test.ts

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+
+/**
+ * "Make this a filter" is the wizard's second entry (#477 clause 1.8), and the
+ * step it pushes has to be answered on the view that offered it.
+ *
+ * The affordance is built once by `MailListHeader` and handed down as
+ * `makeFilterSlot`, so any surface can put it on screen — but the wizard is
+ * mounted per surface, and a surface that renders the row without one leaves
+ * the press on a URL nothing answers. That is the dead button clause 1.7 exists
+ * to prevent, and it is invisible in review: the row and the host are two files
+ * apart, and the affordance keeps working everywhere else.
+ *
+ * So the pairing is the assertion. A surface that renders the row names where
+ * its step is answered, and that file is checked to mount a host. A fourth
+ * surface fails here until it does the same.
+ */
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+/** How the chrome's slot is read — `MailListHeader` writes it, everyone else reads it. */
+const RENDERS_SLOT = /\.makeFilterSlot/;
+const MOUNTS_HOST = /<SelectionWizardHost/;
+
+/** Surface that renders the affordance → the file whose composition answers the step. */
+const ANSWERED_BY: Record<string, string> = {
+	"DailyBrief.tsx": "DailyBrief.tsx",
+	"MessageList.tsx": "MessageList.tsx",
+	// The starred list's bar is shared with the brief's, so its host is mounted
+	// by the view rather than beside the bar.
+	"ThreadListInteraction.tsx": "FlaggedList.tsx",
+};
+
+const read = (file: string): string =>
+	readFileSync(resolve(here, file), "utf8");
+
+const surfacesRenderingTheAffordance = (): string[] =>
+	readdirSync(here)
+		.filter((file) => file.endsWith(".tsx"))
+		.filter((file) => RENDERS_SLOT.test(read(file)));
+
+describe("the make-filter entry", () => {
+	it("is rendered only by surfaces that say where its step is answered", () => {
+		assert.deepEqual(
+			surfacesRenderingTheAffordance().sort(),
+			Object.keys(ANSWERED_BY).sort(),
+		);
+	});
+
+	it("is answered by a mounted wizard on every one of them", () => {
+		for (const [surface, host] of Object.entries(ANSWERED_BY)) {
+			assert.match(
+				read(host),
+				MOUNTS_HOST,
+				`${surface} is answered by ${host}`,
+			);
+		}
+	});
+});

package/src/components/settings/FilterEditor.tsx

@@ -74,7 +74,7 @@ export function FilterEditor({
 	const [offerReapply, setOfferReapply] = useState(false);
 	const nextClauseId = useRef(0);
 
-	const preview = useRulePreview(accountId, rulePredicate(rule));
+	const { count: preview } = useRulePreview(accountId, rulePredicate(rule));
 	const update = useUpdateFilter(accountId, filter.filterId);
 	const organizeJob = useOrganizeJob(accountId);
 	const { createFolder } = useCreateMailbox(accountId);

package/src/hooks/useCreateMailbox.ts

@@ -40,16 +40,23 @@ import { composeFolderPath, validateNewFolderName } from "@/lib/new-folder";
  * `mutation` is exposed for callers that drive their own form state and want the
  * optimistic, non-waiting create (the standalone settings create).
  */
-export function useCreateMailbox(accountId: string) {
+export function useCreateMailbox(accountId: string | undefined) {
 	const queryClient = useQueryClient();
 
-	const { data } = useQuery(
-		mailboxOperationsListMailboxesOptions({ path: { accountId } }),
-	);
+	// Held by surfaces that are mounted before a selection has named an account —
+	// the selection wizard sits beside every list — so the folder list is only
+	// asked for once there is an account to ask about.
+	const { data } = useQuery({
+		...mailboxOperationsListMailboxesOptions({
+			path: { accountId: accountId ?? "" },
+		}),
+		enabled: !!accountId,
+	});
 
 	const mutation = useMutation({
 		...mailboxOperationsCreateMailboxMutation(),
 		onSuccess: () => {
+			if (!accountId) return;
 			queryClient.invalidateQueries({
 				queryKey: mailboxOperationsListMailboxesQueryKey({
 					path: { accountId },
@@ -64,6 +71,11 @@ export function useCreateMailbox(accountId: string) {
 
 	const createFolder = useCallback(
 		async (name: string, signal?: AbortSignal): Promise<FolderOption> => {
+			if (!accountId) {
+				throw new Error(
+					"No account to create the folder in. Pick messages from a single account first.",
+				);
+			}
 			const fullPath = composeFolderPath(name);
 			let mailboxId = pendingByPath.current.get(fullPath);
 			if (!mailboxId) {

package/src/hooks/useFilters.ts

@@ -60,7 +60,7 @@ export const useCreateFilter = (accountId: string | undefined) => {
 			});
 		},
 	});
-	const { mutate } = mutation;
+	const { mutate, mutateAsync } = mutation;
 
 	const createFilter = useCallback(
 		(
@@ -77,8 +77,37 @@ export const useCreateFilter = (accountId: string | undefined) => {
 		[accountId, mutate],
 	);
 
+	/**
+	 * The same create, resolved once the server has the filter, for work that has
+	 * to follow it — the pass over the mail already in the mailbox. Chaining that
+	 * to the request rather than to the surface is what keeps it running when the
+	 * surface is closed while the create is still in flight.
+	 *
+	 * `false` means the create did not land. The failure itself is on `isError`,
+	 * which is what the surface reports and retries from, so it is not raised a
+	 * second time here.
+	 */
+	const createFilterAsync = useCallback(
+		async (
+			draft: OrganizeDraft,
+			scope: Extract<OrganizeScope, "standing" | "temporary">,
+			name: string,
+		): Promise<boolean> => {
+			if (!accountId) return false;
+			return mutateAsync({
+				path: { accountId },
+				body: buildCreateFilterInput(draft, scope, name),
+			}).then(
+				() => true,
+				() => false,
+			);
+		},
+		[accountId, mutateAsync],
+	);
+
 	return {
 		createFilter,
+		createFilterAsync,
 		isPending: mutation.isPending,
 		isSuccess: mutation.isSuccess,
 		isError: mutation.isError,

package/src/hooks/useMatchSample.ts

@@ -0,0 +1,63 @@
+import { messageOperationsDescribeMessageOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type { RemitImapDescribeMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { senderLabel, type WizardMessage } from "@remit/ui";
+import { useQueries } from "@tanstack/react-query";
+import { formatEmailDate } from "@/lib/format";
+
+/**
+ * The members of a match, read from the server that matched them.
+ *
+ * A widened match reaches mail the list never loaded, so these rows cannot come
+ * from the browser's own cache: an intersection with whatever happens to be
+ * loaded shows a handful of rows, or none, beside a server count of hundreds —
+ * which reads as "this matches nothing", the one conclusion #477 3.5 exists to
+ * prevent. The ids the count was counted over are the match, and the server
+ * describes each of them.
+ *
+ * Bounded to the first {@link SAMPLE_LIMIT}: the screen shows a sample in its
+ * own scrolling region and states the total beside it, so describing the whole
+ * match would be requests nobody reads.
+ */
+export const SAMPLE_LIMIT = 12;
+
+export interface MatchSample {
+	messages: WizardMessage[];
+	/** No rows yet because they are still arriving, which is not "no rows". */
+	isPending: boolean;
+}
+
+const toWizardMessage = (
+	described: RemitImapDescribeMessageResponse,
+): WizardMessage => {
+	const { envelope } = described;
+	const from = envelope.from[0];
+	return {
+		id: envelope.messageId,
+		sender: from
+			? senderLabel({
+					normalizedEmail: from.normalizedEmail,
+					displayName: from.displayName,
+				})
+			: "Unknown",
+		subject: envelope.subject ?? "(No subject)",
+		date: formatEmailDate(envelope.date),
+	};
+};
+
+export const useMatchSample = (messageIds: readonly string[]): MatchSample =>
+	useQueries({
+		queries: messageIds.slice(0, SAMPLE_LIMIT).map((messageId) => ({
+			...messageOperationsDescribeMessageOptions({ path: { messageId } }),
+			staleTime: Number.POSITIVE_INFINITY,
+		})),
+		combine: (results) => ({
+			messages: results
+				.map((result) => result.data)
+				.filter(
+					(data): data is RemitImapDescribeMessageResponse =>
+						data !== undefined,
+				)
+				.map(toWizardMessage),
+			isPending: results.some((result) => result.isPending),
+		}),
+	});

package/src/hooks/useRulePreview.ts

@@ -1,5 +1,5 @@
 import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { PreviewCount } from "@remit/ui";
+import { type PreviewCount, UNCOUNTABLE_PREDICATE_REASON } from "@remit/ui";
 import { useMutation } from "@tanstack/react-query";
 import { useEffect, useRef, useState } from "react";
 import { buildOrganizeInput } from "@/lib/organize/organize-model";
@@ -9,7 +9,6 @@ import {
 	PREVIEW_DEBOUNCE_MS,
 	type PreviewState,
 	predicateSignature,
-	UNCOUNTABLE_PREDICATE_REASON,
 } from "@/lib/organize/rule-model";
 import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
 
@@ -28,12 +27,22 @@ import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
  * `seedCount` is the opening count a widen probe already knows; omit it (as the
  * settings editor does, having no probe) to open on `loading` and preview the
  * loaded predicate immediately.
+ *
+ * `matchedIds` are the ids that count was counted over — the server's own
+ * answer, bounded to the same cap the apply pass uses. A caller applying an
+ * action the back-apply job cannot express (a delete, a read flag) acts on
+ * exactly these rather than paging the list in the browser (#477 5.3).
  */
+export interface RulePreview {
+	count: PreviewCount;
+	matchedIds: readonly string[];
+}
+
 export const useRulePreview = (
 	accountId: string | undefined,
 	predicate: OrganizeMatchPredicate,
 	seedCount?: number,
-): PreviewCount => {
+): RulePreview => {
 	const mutation = useMutation(organizeOperationsPreviewOrganizeMutation());
 	const { mutateAsync } = mutation;
 	const currentSignature = predicateSignature(predicate);
@@ -68,6 +77,7 @@ export const useRulePreview = (
 					if (latestRequested.current !== signature) return;
 					setState({
 						count: response.matchedCount,
+						matchedIds: response.messageIds,
 						previewedSignature: signature,
 					});
 				})
@@ -95,7 +105,16 @@ export const useRulePreview = (
 	]);
 
 	if (!countable) {
-		return { status: "error", reason: UNCOUNTABLE_PREDICATE_REASON };
+		return {
+			count: { status: "error", reason: UNCOUNTABLE_PREDICATE_REASON },
+			matchedIds: [],
+		};
 	}
-	return derivePreview(state, currentSignature);
+	return {
+		count: derivePreview(state, currentSignature),
+		matchedIds:
+			state.previewedSignature === currentSignature
+				? (state.matchedIds ?? [])
+				: [],
+	};
 };

package/src/lib/list-header-chrome.ts

@@ -1,3 +1,4 @@
+import type { SearchConversion } from "@remit/ui";
 import { createContext, type ReactNode, useContext } from "react";
 
 /**
@@ -31,6 +32,15 @@ export interface ListHeaderChrome {
 	searchResults: ReactNode;
 	/** The search's make-this-a-filter row, up only while nothing is ticked. */
 	makeFilterSlot: ReactNode;
+	/**
+	 * The active query as clauses, which is what the wizard's search entry opens
+	 * on (#484). It travels with the chrome for the same reason the rest does:
+	 * the query belongs to `MailListHeader` and the wizard is mounted by the body
+	 * below it, and one conversion computed in one place is what keeps the reason
+	 * the affordance gives and the clauses the wizard seeds from disagreeing.
+	 * Absent when no query is up.
+	 */
+	searchConversion?: SearchConversion;
 }
 
 const NO_CHROME: ListHeaderChrome = {

package/src/lib/mail-context.ts

@@ -54,13 +54,6 @@ export interface MailContextValue {
 	onToggleIntelligence: () => void;
 	/** Set the pane open/closed and persist the choice (desktop default-open). */
 	onSetIntelligenceOpen: (open: boolean) => void;
-	/**
-	 * How many rows the list has ticked. The selection is owned by the list, and
-	 * surfaces mounted beside it — the selection wizard (#477) — need the same
-	 * number the bar is counting rather than one of their own.
-	 */
-	selectedCount: number;
-	onSelectedCountChange: (count: number) => void;
 }
 
 export const MailContext = createContext<MailContextValue | null>(null);
@@ -85,8 +78,6 @@ export const useMailContext = (): MailContextValue => {
 			intelligenceOpen: false,
 			onToggleIntelligence: () => {},
 			onSetIntelligenceOpen: () => {},
-			selectedCount: 0,
-			onSelectedCountChange: () => {},
 		}
 	);
 };

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

@@ -1,11 +1,14 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import type { RuleClause } from "@remit/ui";
 import {
 	buildCreateFilterInput,
 	buildOrganizeInput,
+	buildWizardDraft,
 	hasCommittableAction,
 	NO_ACTION,
 	type OrganizeDraft,
+	organizeScopeFor,
 } from "./organize-model";
 
 const baseDraft = (overrides: Partial<OrganizeDraft> = {}): OrganizeDraft => ({
@@ -130,3 +133,110 @@ describe("buildCreateFilterInput", () => {
 		assert.equal(input.actionLabelId, "lbl-1");
 	});
 });
+
+describe("organizeScopeFor", () => {
+	it("reads the ticked list at scope once as just-these", () => {
+		assert.equal(organizeScopeFor({ mode: "selected" }), "just-these");
+		assert.equal(
+			organizeScopeFor({ mode: "selected", ruleScope: "once" }),
+			"just-these",
+		);
+	});
+
+	it("reads either widened door at scope once as all-like-these", () => {
+		assert.equal(organizeScopeFor({ mode: "similar" }), "all-like-these");
+		assert.equal(
+			organizeScopeFor({ mode: "properties", ruleScope: "once" }),
+			"all-like-these",
+		);
+	});
+
+	it("reads the two persisting scopes off the scope answer alone", () => {
+		for (const mode of ["selected", "similar", "properties"] as const) {
+			assert.equal(
+				organizeScopeFor({ mode, ruleScope: "standing" }),
+				"standing",
+			);
+			assert.equal(organizeScopeFor({ mode, ruleScope: "until" }), "temporary");
+		}
+	});
+});
+
+describe("buildWizardDraft", () => {
+	const clauses: RuleClause[] = [
+		{ id: "c1", field: "From", value: "noreply@booking.com" },
+	];
+
+	it("turns the until scope's civil date into a zoned expiresAt", () => {
+		const draft = buildWizardDraft({
+			mode: "properties",
+			ruleScope: "until",
+			clauses,
+			matchOperator: "any",
+			moveMailboxId: "mbx-2",
+			until: "2026-09-30",
+		});
+		assert.match(
+			draft.expiresAt ?? "",
+			/^2026-09-30T23:59:59[+-]\d{2}:\d{2}$/,
+			"the day the rule stops on becomes an instant with an offset",
+		);
+	});
+
+	it("carries no expiry for the scopes that never expire", () => {
+		for (const ruleScope of ["once", "standing"] as const) {
+			const draft = buildWizardDraft({
+				mode: "properties",
+				ruleScope,
+				clauses,
+				matchOperator: "all",
+				until: "2026-09-30",
+			});
+			assert.equal(draft.expiresAt, undefined);
+		}
+	});
+
+	it("anchors on the ticked messages only while the similar door is matching", () => {
+		const anchored = buildWizardDraft({
+			mode: "similar",
+			anchorMessageId: "msg-1",
+			clauses: [],
+			matchOperator: "all",
+		});
+		assert.equal(anchored.anchorMessageId, "msg-1");
+
+		const literal = buildWizardDraft({
+			mode: "properties",
+			anchorMessageId: "msg-1",
+			clauses,
+			matchOperator: "any",
+		});
+		assert.equal("anchorMessageId" in literal, false);
+	});
+
+	it("maps the wizard's operator onto the API's", () => {
+		assert.equal(
+			buildWizardDraft({ mode: "properties", clauses, matchOperator: "all" })
+				.matchOperator,
+			"And",
+		);
+		assert.equal(
+			buildWizardDraft({ mode: "properties", clauses, matchOperator: "any" })
+				.matchOperator,
+			"Or",
+		);
+	});
+
+	it("sends the clause field and value, and nothing the chip carries besides", () => {
+		const draft = buildWizardDraft({
+			mode: "properties",
+			clauses: [
+				{ id: "c1", field: "Subject", value: "receipt", derived: true },
+			],
+			matchOperator: "all",
+		});
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "Subject", value: "receipt" },
+		]);
+	});
+});

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

@@ -5,6 +5,13 @@ import type {
 	RemitImapFilterScope,
 	RemitImapOrganizeInput,
 } from "@remit/api-http-client/types.gen.ts";
+import type {
+	MatchMode,
+	MatchOperator,
+	RuleClause,
+	RuleScope,
+} from "@remit/ui";
+import { pickedDateToExpiresAt } from "./filter-status";
 
 /**
  * The four commit scopes the smart-organize sentence offers (RFC 034 recap):
@@ -92,6 +99,68 @@ export const buildOrganizeInput = (
 	actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
 });
 
+/**
+ * The two independent answers the wizard collects (#477 4.6). Neither is a
+ * scope: the door says what the action covers and the scope step says how long
+ * it holds, and the four `OrganizeScope` values fall out of the pair.
+ */
+export interface WizardCommitAnswers {
+	mode: MatchMode;
+	/** Absent on the verbs that never reach the scope step — those act once. */
+	ruleScope?: RuleScope;
+}
+
+/**
+ * Which of the four commit scopes the wizard's answers add up to. Reconstructed
+ * here and nowhere else, so a driver cannot invent a fifth: the ticked list at
+ * scope once is `just-these`, a widened door at scope once is `all-like-these`,
+ * and the two persisting scopes are `standing` and `temporary`.
+ */
+export const organizeScopeFor = ({
+	mode,
+	ruleScope,
+}: WizardCommitAnswers): OrganizeScope => {
+	if (ruleScope === "standing") return "standing";
+	if (ruleScope === "until") return "temporary";
+	return mode === "selected" ? "just-these" : "all-like-these";
+};
+
+export interface WizardDraftInput extends WizardCommitAnswers {
+	/** The semantic anchor, present only while the similar door is the matcher. */
+	anchorMessageId?: string;
+	clauses: readonly RuleClause[];
+	matchOperator: MatchOperator;
+	moveMailboxId?: string;
+	/** ISO 8601 civil date (`YYYY-MM-DD`) the `until` scope stops on. */
+	until?: string;
+}
+
+/**
+ * The commit draft for a set of wizard answers. This is where the `until`
+ * scope's civil date becomes `expiresAt`, a zoned date-time (#477 5.4): the
+ * wizard collects the day the rule stops on, and the day only becomes an
+ * instant once there is a draft to carry it.
+ */
+export const buildWizardDraft = ({
+	mode,
+	ruleScope,
+	anchorMessageId,
+	clauses,
+	matchOperator,
+	moveMailboxId,
+	until,
+}: WizardDraftInput): OrganizeDraft => ({
+	...(mode === "similar" && anchorMessageId ? { anchorMessageId } : {}),
+	matchOperator: matchOperator === "all" ? "And" : "Or",
+	literalClauses: clauses.map((clause) => ({
+		field: clause.field,
+		value: clause.value,
+	})),
+	moveMailboxId,
+	expiresAt:
+		ruleScope === "until" ? pickedDateToExpiresAt(until ?? "") : undefined,
+});
+
 /**
  * Build the `createFilter` body for a standing or temporary filter. `ttl` is
  * derived server-side from `expiresAt`; `expiresAt` is sent only for the

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

@@ -207,10 +207,6 @@ export const isEvaluablePredicate = (
 	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
@@ -254,6 +250,8 @@ export const ruleToDraft = (
 export interface PreviewState {
 	/** The last count that came back, `undefined` before the first lands. */
 	count?: number;
+	/** The ids that count was counted over, as the server bounded them. */
+	matchedIds?: readonly string[];
 	/** The signature the {@link count} was counted for. */
 	previewedSignature?: string;
 	/** The signature the last error was raised for. */

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

@@ -15,6 +15,8 @@ import {
 } from "@remit/ui";
 import {
 	ownedHistoryEntries,
+	wizardEntryFromParam,
+	wizardEntryValue,
 	wizardStepFromParam,
 	wizardStepValue,
 } from "./wizard-history.js";
@@ -72,6 +74,17 @@ describe("re-rooting a wizard that was loaded into", () => {
 		);
 	});
 
+	// The root is the wizard-closed state, so it carries neither the step nor
+	// the affordance that opened it; otherwise closing the wizard leaves the
+	// entry marker behind in the address bar (#484).
+	it("puts the wizard back on a root that names no entry", () => {
+		assert.match(source, /wizard: undefined,\s*\n\s*wizardFrom: undefined,/);
+		assert.match(
+			source,
+			/wizard: openingStep,\s*\n\s*wizardFrom: openingEntry,/,
+		);
+	});
+
 	it("is never armed by a step the app pushed", () => {
 		const goToStep = source.slice(source.indexOf("const goToStep"));
 		assert.doesNotMatch(goToStep, /loadedHoldingStep/);
@@ -107,6 +120,24 @@ describe("the wizard step in the URL", () => {
 	});
 });
 
+describe("which affordance opened the wizard", () => {
+	it("reads the search entry, and everything else as the selection bar", () => {
+		assert.equal(wizardEntryFromParam("search"), "search");
+		for (const value of [undefined, "", "Search", "bar", 1, null, {}]) {
+			assert.equal(wizardEntryFromParam(value), undefined);
+		}
+	});
+
+	it("never fails validation, so a mistyped link still lands on the mail", () => {
+		for (const value of ["nope", "SEARCH", 7, [], null, undefined]) {
+			const parsed = wizardEntryValue.safeParse(value);
+			assert.ok(parsed.success);
+			assert.equal(parsed.data, undefined);
+		}
+		assert.equal(wizardEntryValue.parse("search"), "search");
+	});
+});
+
 describe("the history entries the wizard owns", () => {
 	it("is one per step reached, on every shape of the list", () => {
 		for (const answers of answerSets()) {