@remit/web-client 0.0.91 → 0.0.93

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

@@ -78,7 +78,11 @@ export function SearchFilterEditor({
 		[mailboxesData?.items],
 	);
 
-	const preview = useRulePreview(accountId, rulePredicate(rule), seedCount);
+	const { count: preview } = useRulePreview(
+		accountId,
+		rulePredicate(rule),
+		seedCount,
+	);
 
 	const organizeJob = useOrganizeJob(accountId);
 	const createFilter = useCreateFilter(accountId);

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

@@ -28,12 +28,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 +78,7 @@ export const useRulePreview = (
 					if (latestRequested.current !== signature) return;
 					setState({
 						count: response.matchedCount,
+						matchedIds: response.messageIds,
 						previewedSignature: signature,
 					});
 				})
@@ -95,7 +106,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/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

@@ -254,6 +254,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/selection-mode.test.ts

@@ -28,17 +28,31 @@ describe("deriveIsMultiSelectMode", () => {
 
 describe("shouldExitSelectionOnNavigate", () => {
 	test("back while selecting exits selection instead of navigating", () => {
-		assert.equal(shouldExitSelectionOnNavigate("BACK", true), true);
+		assert.equal(shouldExitSelectionOnNavigate("BACK", true, undefined), true);
 	});
 
 	test("back with nothing selected is left alone", () => {
-		assert.equal(shouldExitSelectionOnNavigate("BACK", false), false);
+		assert.equal(
+			shouldExitSelectionOnNavigate("BACK", false, undefined),
+			false,
+		);
+	});
+
+	test("back inside the wizard pops a step instead of the selection", () => {
+		assert.equal(shouldExitSelectionOnNavigate("BACK", true, "match"), false);
+		assert.equal(shouldExitSelectionOnNavigate("BACK", true, "review"), false);
 	});
 
 	test("forward, push, replace and go are never blocked", () => {
-		assert.equal(shouldExitSelectionOnNavigate("FORWARD", true), false);
-		assert.equal(shouldExitSelectionOnNavigate("PUSH", true), false);
-		assert.equal(shouldExitSelectionOnNavigate("REPLACE", true), false);
-		assert.equal(shouldExitSelectionOnNavigate("GO", true), false);
+		assert.equal(
+			shouldExitSelectionOnNavigate("FORWARD", true, undefined),
+			false,
+		);
+		assert.equal(shouldExitSelectionOnNavigate("PUSH", true, undefined), false);
+		assert.equal(
+			shouldExitSelectionOnNavigate("REPLACE", true, undefined),
+			false,
+		);
+		assert.equal(shouldExitSelectionOnNavigate("GO", true, undefined), false);
 	});
 });

package/src/lib/selection-mode.ts

@@ -3,6 +3,8 @@
  * and 10). Pure so "one source of truth, one exit" is testable without a DOM.
  */
 
+import type { StepId } from "@remit/ui";
+
 /** The subset of `@tanstack/history`'s `HistoryAction` a blocker can see. */
 export type NavigationAction = "PUSH" | "REPLACE" | "FORWARD" | "BACK" | "GO";
 
@@ -22,8 +24,13 @@ export const deriveIsMultiSelectMode = (
  * Whether a history navigation should exit selection mode instead of leaving
  * the route. Only the back gesture is intercepted, so a navigation the app
  * itself starts (opening a message, switching mailboxes) is never blocked.
+ *
+ * While the selection wizard is open its own steps own the back gesture, and
+ * the selection is what the wizard is acting on — swallowing back there would
+ * clear the selection out from under the flow instead of popping a step.
  */
 export const shouldExitSelectionOnNavigate = (
 	action: NavigationAction,
 	hasSelection: boolean,
-): boolean => action === "BACK" && hasSelection;
+	wizardStep: StepId | undefined,
+): boolean => action === "BACK" && hasSelection && wizardStep === undefined;

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

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import {
+	backExits,
+	type MatchMode,
+	type RuleScope,
+	type StepId,
+	stepIndex,
+	stepsFor,
+	type Verb,
+	type WizardAnswers,
+} from "@remit/ui";
+import {
+	ownedHistoryEntries,
+	wizardStepFromParam,
+	wizardStepValue,
+} from "./wizard-history.js";
+
+const VERBS: readonly Verb[] = [
+	"delete",
+	"move",
+	"junk",
+	"markRead",
+	"organize",
+];
+const MODES: readonly MatchMode[] = ["selected", "similar", "properties"];
+const SCOPES: readonly (RuleScope | undefined)[] = [
+	undefined,
+	"once",
+	"standing",
+	"until",
+];
+
+const answerSets = (): WizardAnswers[] => {
+	const sets: WizardAnswers[] = [];
+	for (const verb of VERBS) {
+		for (const mode of MODES) {
+			for (const scope of SCOPES) {
+				for (const fromSearch of [false, true]) {
+					sets.push({ verb, mode, scope, fromSearch });
+				}
+			}
+		}
+	}
+	return sets;
+};
+
+const here = dirname(fileURLToPath(import.meta.url));
+const source = readFileSync(resolve(here, "wizard-history.ts"), "utf8");
+
+/** The steps up to and including the one an answer is given on. */
+const prefixThrough = (steps: readonly StepId[], step: StepId): StepId[] =>
+	steps.slice(0, steps.indexOf(step) + 1);
+
+/**
+ * The re-root runs inside a router, so the rule is enforced by reading the
+ * source — as `../components/mail/MessageList.selection.test.ts` does for its
+ * own component-level rules. What it pins is where the decision comes from: a
+ * step the app itself pushed must never be re-rooted, or the push that opens
+ * the wizard from a verb (#483) duplicates the entry underneath it and the
+ * first back after Cancel appears to do nothing.
+ */
+describe("re-rooting a wizard that was loaded into", () => {
+	it("decides from what the first render held, not from a flag", () => {
+		assert.match(source, /useRef\(step !== undefined\)/);
+		assert.match(
+			source,
+			/if \(!loadedHoldingStep\.current\) return;\s*\n\s*loadedHoldingStep\.current = false;/,
+		);
+	});
+
+	it("is never armed by a step the app pushed", () => {
+		const goToStep = source.slice(source.indexOf("const goToStep"));
+		assert.doesNotMatch(goToStep, /loadedHoldingStep/);
+	});
+
+	it("does not re-run when the step changes", () => {
+		assert.doesNotMatch(source, /\}, \[step, openingStep, navigate\]\)/);
+	});
+});
+
+describe("the wizard step in the URL", () => {
+	it("round-trips every step the wizard can reach", () => {
+		for (const answers of answerSets()) {
+			for (const step of stepsFor(answers)) {
+				assert.equal(wizardStepFromParam(step), step);
+			}
+		}
+	});
+
+	it("reads a value the wizard cannot be on as no step", () => {
+		for (const value of [undefined, "", "Match", "step-1", 2, null, {}]) {
+			assert.equal(wizardStepFromParam(value), undefined);
+		}
+	});
+
+	it("never fails validation, so a mistyped link still lands on the mail", () => {
+		for (const value of ["nope", "MATCH", "run ", 7, [], null, undefined]) {
+			const parsed = wizardStepValue.safeParse(value);
+			assert.ok(parsed.success);
+			assert.equal(parsed.data, undefined);
+		}
+		assert.equal(wizardStepValue.parse("review"), "review");
+	});
+});
+
+describe("the history entries the wizard owns", () => {
+	it("is one per step reached, on every shape of the list", () => {
+		for (const answers of answerSets()) {
+			const steps = stepsFor(answers);
+			steps.forEach((step, position) => {
+				assert.equal(ownedHistoryEntries(steps, step), position + 1);
+			});
+		}
+	});
+
+	it("cannot be moved by the match door, which is answered before it", () => {
+		for (const verb of VERBS) {
+			for (const scope of SCOPES) {
+				const prefixes = MODES.map((mode) =>
+					prefixThrough(stepsFor({ verb, mode, scope }), "match"),
+				);
+				for (const prefix of prefixes) {
+					assert.deepEqual(prefix, prefixes[0]);
+					for (const step of prefix) {
+						const counts = MODES.map((mode) =>
+							ownedHistoryEntries(stepsFor({ verb, mode, scope }), step),
+						);
+						assert.equal(new Set(counts).size, 1);
+					}
+				}
+			}
+		}
+	});
+
+	it("cannot be moved by the scope, which is answered before it", () => {
+		for (const mode of MODES) {
+			for (const fromSearch of [false, true]) {
+				const listFor = (scope: RuleScope | undefined) =>
+					stepsFor({ verb: "organize", mode, scope, fromSearch });
+				const prefixes = SCOPES.map((scope) =>
+					prefixThrough(listFor(scope), "rule"),
+				);
+				for (const prefix of prefixes) {
+					assert.deepEqual(prefix, prefixes[0]);
+					for (const step of prefix) {
+						const counts = SCOPES.map((scope) =>
+							ownedHistoryEntries(listFor(scope), step),
+						);
+						assert.equal(new Set(counts).size, 1);
+					}
+				}
+			}
+		}
+	});
+
+	it("rewinds the whole flow from the steps Back leaves on", () => {
+		for (const answers of answerSets()) {
+			const steps = stepsFor(answers);
+			assert.ok(backExits(steps, steps[0]));
+			assert.equal(ownedHistoryEntries(steps, steps[0]), 1);
+			const run = steps[steps.length - 1];
+			assert.ok(backExits(steps, run));
+			assert.equal(ownedHistoryEntries(steps, run), steps.length);
+		}
+	});
+
+	it("holds a step the answers dropped to the opening entry", () => {
+		const steps = stepsFor({ verb: "delete", mode: "selected" });
+		assert.equal(stepIndex(steps, "properties"), 0);
+		assert.equal(ownedHistoryEntries(steps, "properties"), 1);
+	});
+});