@remit/web-client 0.0.194 → 0.0.196

package/src/hooks/useDeleteFolder.ts

@@ -1,11 +1,13 @@
 import {
 	configOperationsGetConfigQueryKey,
 	mailboxOperationsListMailboxesQueryKey,
+	syncOperationsGetSyncStatusOptions,
 } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import {
 	mailboxDetailOperationsDeleteMailbox,
 	mailboxOperationsListMailboxes,
 	messageBulkOperationsMoveMessages,
+	syncOperationsTriggerSync,
 	threadOperationsListThreads,
 } from "@remit/api-http-client/sdk.gen.ts";
 import { useQueryClient } from "@tanstack/react-query";
@@ -17,6 +19,12 @@ import {
 	MOVE_BATCH_SIZE,
 	type MoveProgress,
 } from "@/lib/delete-folder";
+import {
+	awaitFreshMailboxCount,
+	type FreshCountOutcome,
+	type MailboxCountReading,
+	mailboxSyncStamp,
+} from "@/lib/fresh-mailbox-count";
 
 const PAGE_CAP = 50;
 
@@ -101,11 +109,25 @@ const liveMessageCount = async (
 
 export type DeleteFolderPhase =
 	| "idle"
+	| "checking"
+	| "check-stalled"
 	| "moving"
 	| "deleting"
 	| "done"
 	| "error";
 
+/**
+ * What a delete-as-empty did. `blocked` carries the count that stopped it;
+ * `pending` means the server has not reported yet and the user decides whether
+ * to wait on; `failed` means nothing was established. Neither is ever treated
+ * as empty.
+ */
+export type EmptyDeleteOutcome =
+	| { status: "deleted" }
+	| { status: "blocked"; messageCount: number }
+	| { status: "pending" }
+	| { status: "failed" };
+
 interface UseDeleteFolderOptions {
 	accountId: string;
 	mailboxId: string;
@@ -121,7 +143,11 @@ export function useDeleteFolder({
 	const [phase, setPhase] = useState<DeleteFolderPhase>("idle");
 	const [progress, setProgress] = useState<MoveProgress | null>(null);
 	const [errorMessage, setErrorMessage] = useState<string>();
+	const [checkStartedAt, setCheckStartedAt] = useState<number>();
 	const abortRef = useRef<AbortController | null>(null);
+	/** The folder's sync stamp before the round was asked for; set while a check
+	 * is running or paused, so resuming it re-uses the same baseline. */
+	const sinceRef = useRef<number | undefined>(undefined);
 
 	const invalidate = useCallback(() => {
 		queryClient.invalidateQueries({
@@ -163,6 +189,88 @@ export function useDeleteFolder({
 		[accountId, mailboxId],
 	);
 
+	const readMailboxSyncStatus = useCallback(
+		(): Promise<readonly MailboxCountReading[]> =>
+			queryClient
+				.fetchQuery({
+					...syncOperationsGetSyncStatusOptions({ path: { accountId } }),
+					staleTime: 0,
+				})
+				.then((data) => data.mailboxes ?? []),
+		[queryClient, accountId],
+	);
+
+	/**
+	 * Delete a folder the user was told is empty. Every count the client holds is
+	 * the last sync round's, so this waits (R2 of the IMAP mutation rules) for a
+	 * round asked for here to report on the folder, and deletes only on the count
+	 * that round read. A read failure or a folder gone from the account refuses
+	 * the delete: not knowing what a folder holds is never permission.
+	 *
+	 * The round can take minutes — it fans the whole account out behind INBOX —
+	 * so the wait runs in segments. A segment that ends unreported returns
+	 * `pending` and the user decides; calling again resumes the same wait against
+	 * the same baseline, and never asks for a second round.
+	 */
+	const deleteIfEmpty = useCallback(async (): Promise<EmptyDeleteOutcome> => {
+		const controller = new AbortController();
+		abortRef.current = controller;
+		const { signal } = controller;
+		setPhase("checking");
+		setErrorMessage(undefined);
+
+		const resuming = sinceRef.current !== undefined;
+		const counted = await attempt(
+			(async (): Promise<FreshCountOutcome> => {
+				if (!resuming) {
+					signal.throwIfAborted();
+					sinceRef.current = mailboxSyncStamp(
+						await readMailboxSyncStatus(),
+						mailboxId,
+					);
+					signal.throwIfAborted();
+					setCheckStartedAt(Date.now());
+					await syncOperationsTriggerSync({
+						path: { accountId },
+						throwOnError: true,
+					});
+				}
+				return awaitFreshMailboxCount({
+					readMailboxes: readMailboxSyncStatus,
+					mailboxId,
+					since: sinceRef.current ?? 0,
+					signal,
+				});
+			})(),
+		);
+
+		if (signal.aborted) {
+			// The dialog is closing or the user cancelled; leave nothing running
+			// and no phase for a later caller to inherit.
+			setPhase("idle");
+			sinceRef.current = undefined;
+			return { status: "failed" };
+		}
+		if (!counted.ok) {
+			sinceRef.current = undefined;
+			setErrorMessage(counted.error);
+			setPhase("error");
+			return { status: "failed" };
+		}
+		if (counted.value.status === "pending") {
+			setPhase("check-stalled");
+			return { status: "pending" };
+		}
+		sinceRef.current = undefined;
+		if (counted.value.messageCount > 0) {
+			setPhase("idle");
+			invalidate();
+			return { status: "blocked", messageCount: counted.value.messageCount };
+		}
+		await deleteMailbox();
+		return { status: "deleted" };
+	}, [accountId, mailboxId, readMailboxSyncStatus, deleteMailbox, invalidate]);
+
 	const cancel = useCallback(() => {
 		abortRef.current?.abort();
 	}, []);
@@ -250,16 +358,21 @@ export function useDeleteFolder({
 	const reset = useCallback(() => {
 		abortRef.current?.abort();
 		abortRef.current = null;
+		sinceRef.current = undefined;
 		setPhase("idle");
 		setProgress(null);
 		setErrorMessage(undefined);
+		setCheckStartedAt(undefined);
 	}, []);
 
 	return {
 		phase,
 		progress,
 		errorMessage,
+		/** When the running check asked for its round; the surface shows the wait. */
+		checkStartedAt,
 		deleteMailbox,
+		deleteIfEmpty,
 		moveThenDelete,
 		cancel,
 		reset,

package/src/lib/delete-folder.test.ts

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import {
 	advanceMove,
 	beginMove,
+	elapsedLabel,
 	excludeFolder,
 	type FolderNode,
 	failMove,
@@ -262,6 +263,19 @@ describe("move progress", () => {
 	});
 });
 
+describe("elapsedLabel", () => {
+	it("counts a wait in minutes and padded seconds", () => {
+		assert.equal(elapsedLabel(0), "0:00");
+		assert.equal(elapsedLabel(9_400), "0:09");
+		assert.equal(elapsedLabel(65_000), "1:05");
+		assert.equal(elapsedLabel(600_000), "10:00");
+	});
+
+	it("reads a backwards clock as no time at all", () => {
+		assert.equal(elapsedLabel(-5_000), "0:00");
+	});
+});
+
 describe("initialStage", () => {
 	it("opens on the empty confirm for a folder with no mail", () => {
 		assert.equal(initialStage(0), "confirm-empty");

package/src/lib/delete-folder.ts

@@ -172,6 +172,12 @@ export function moveProgressLabel(progress: MoveProgress): string {
 	return `Moved ${progress.moved} of ${progress.total}`;
 }
 
+/** How long a wait has run, as `m:ss` — clamped at zero so a clock skew reads as 0:00. */
+export function elapsedLabel(ms: number): string {
+	const seconds = Math.max(0, Math.floor(ms / 1000));
+	return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+}
+
 /** Where the wizard opens: a straight confirm for an empty folder, otherwise the fate step. */
 export function initialStage(
 	messageCount: number,

package/src/lib/folder-roles.test.ts

@@ -3,7 +3,6 @@ import { describe, test } from "node:test";
 import type { RemitImapFolderAppointment } from "@remit/api-http-client/types.gen.ts";
 import {
 	buildMailboxRoleMap,
-	getMailboxDisplayName,
 	labelForMailbox,
 	shouldShowUnreadBadgeForRole,
 } from "./folder-roles.js";
@@ -43,16 +42,6 @@ describe("buildMailboxRoleMap", () => {
 	});
 });
 
-describe("getMailboxDisplayName", () => {
-	test("returns the leaf segment of a nested path", () => {
-		assert.equal(getMailboxDisplayName("INBOX/Sent Messages"), "Sent Messages");
-	});
-
-	test("returns the whole path when there is no delimiter", () => {
-		assert.equal(getMailboxDisplayName("INBOX"), "INBOX");
-	});
-});
-
 describe("labelForMailbox", () => {
 	const t = (key: string, fallback: string) =>
 		key === "sidebar.sent" ? "Verzonden" : fallback;
@@ -60,7 +49,11 @@ describe("labelForMailbox", () => {
 	test("a trimmed displayNameOverride wins over everything", () => {
 		assert.equal(
 			labelForMailbox(
-				{ fullPath: "INBOX/Sent", displayNameOverride: "  My Sent  " },
+				{
+					fullPath: "INBOX/Sent",
+					hierarchyDelimiter: "/",
+					displayNameOverride: "  My Sent  ",
+				},
 				"sent",
 				t,
 			),
@@ -70,26 +63,44 @@ describe("labelForMailbox", () => {
 
 	test("falls back to the translated canonical role label", () => {
 		assert.equal(
-			labelForMailbox({ fullPath: "INBOX/Verzonden" }, "sent", t),
+			labelForMailbox(
+				{ fullPath: "INBOX/Verzonden", hierarchyDelimiter: "/" },
+				"sent",
+				t,
+			),
 			"Verzonden",
 		);
 	});
 
 	test("falls back to the provider leaf when there is no role", () => {
 		assert.equal(
-			labelForMailbox({ fullPath: "INBOX/Nieuwsbrieven" }, undefined, t),
+			labelForMailbox(
+				{ fullPath: "INBOX/Nieuwsbrieven", hierarchyDelimiter: "/" },
+				undefined,
+				t,
+			),
 			"Nieuwsbrieven",
 		);
 	});
 
 	test("falls back to the leaf when no translator is supplied", () => {
-		assert.equal(labelForMailbox({ fullPath: "INBOX/Sent" }, "sent"), "Sent");
+		assert.equal(
+			labelForMailbox(
+				{ fullPath: "INBOX/Sent", hierarchyDelimiter: "/" },
+				"sent",
+			),
+			"Sent",
+		);
 	});
 
 	test("a blank/whitespace override is ignored", () => {
 		assert.equal(
 			labelForMailbox(
-				{ fullPath: "INBOX/Sent", displayNameOverride: "   " },
+				{
+					fullPath: "INBOX/Sent",
+					hierarchyDelimiter: "/",
+					displayNameOverride: "   ",
+				},
 				"sent",
 				t,
 			),
@@ -98,6 +109,38 @@ describe("labelForMailbox", () => {
 	});
 });
 
+describe("labelForMailbox — the server’s own delimiter (#877)", () => {
+	test("a dot-delimited nested folder renders its leaf", () => {
+		assert.equal(
+			labelForMailbox(
+				{ fullPath: "INBOX.Projects.Q3", hierarchyDelimiter: "." },
+				undefined,
+			),
+			"Q3",
+		);
+	});
+
+	test("a flat namespace renders the whole name", () => {
+		assert.equal(
+			labelForMailbox(
+				{ fullPath: "Projects/Q3", hierarchyDelimiter: "" },
+				undefined,
+			),
+			"Projects/Q3",
+		);
+	});
+
+	test("a slash in a dot-delimited name is part of the name", () => {
+		assert.equal(
+			labelForMailbox(
+				{ fullPath: "INBOX.Reading/Writing", hierarchyDelimiter: "." },
+				undefined,
+			),
+			"Reading/Writing",
+		);
+	});
+});
+
 describe("shouldShowUnreadBadgeForRole", () => {
 	test("hides the badge for Sent, Drafts, and Trash", () => {
 		assert.equal(shouldShowUnreadBadgeForRole("sent"), false);

package/src/lib/folder-roles.ts

@@ -2,6 +2,10 @@ import type {
 	RemitImapCanonicalMailboxRole,
 	RemitImapFolderAppointment,
 } from "@remit/api-http-client/types.gen.ts";
+import {
+	type MailboxPath,
+	mailboxLeafName,
+} from "@remit/data-ports/mailbox-name";
 import type { NavMailboxRole } from "@remit/ui";
 
 /**
@@ -79,12 +83,6 @@ export function buildMailboxRoleMap(
 	return byMailbox;
 }
 
-/** Leaf segment of a provider path (`INBOX/Spam` → `Spam`). */
-export const getMailboxDisplayName = (fullPath: string): string => {
-	const parts = fullPath.split("/");
-	return parts[parts.length - 1] || fullPath;
-};
-
 type Translator = (key: string, fallback: string) => string;
 
 /**
@@ -92,13 +90,13 @@ type Translator = (key: string, fallback: string) => string;
  * canonical localized label for the appointed role, else the provider leaf.
  */
 export function labelForMailbox(
-	mailbox: { fullPath: string; displayNameOverride?: string },
+	mailbox: MailboxPath & { displayNameOverride?: string },
 	role: NavMailboxRole | undefined,
 	t?: Translator,
 ): string {
 	const override = mailbox.displayNameOverride?.trim();
 	if (override) return override;
-	const leaf = getMailboxDisplayName(mailbox.fullPath);
+	const leaf = mailboxLeafName(mailbox);
 	if (!role || !t) return leaf;
 	return t(`sidebar.${role}`, leaf);
 }

package/src/lib/fresh-mailbox-count.test.ts

@@ -0,0 +1,145 @@
+/**
+ * awaitFreshMailboxCount — the gate a folder delete holds behind while the
+ * server is asked what the folder actually holds. It reports a count only from
+ * a round that stamped past the baseline, reports `pending` rather than a count
+ * when the segment runs out, and refuses outright on a folder the account does
+ * not list.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	awaitFreshMailboxCount,
+	FRESH_COUNT_MISSING_MESSAGE,
+	type MailboxCountReading,
+	mailboxSyncStamp,
+} from "./fresh-mailbox-count.js";
+
+const reading = (
+	messagesTotal: number,
+	lastSyncedAt?: number,
+): MailboxCountReading => ({
+	mailboxId: "mbx-1",
+	messagesTotal,
+	lastSyncedAt,
+});
+
+const noDelay = () => Promise.resolve();
+
+/** A clock that jumps a minute per reading, so a segment expires in two polls. */
+const impatientClock = () => {
+	let clock = 0;
+	return () => {
+		clock += 60_000;
+		return clock;
+	};
+};
+
+describe("mailboxSyncStamp", () => {
+	it("reads the folder's stamp, and zero for a folder never synced", () => {
+		assert.equal(mailboxSyncStamp([reading(0, 100)], "mbx-1"), 100);
+		assert.equal(mailboxSyncStamp([reading(0)], "mbx-1"), 0);
+	});
+
+	it("refuses a folder the account does not list", () => {
+		assert.throws(() => mailboxSyncStamp([], "mbx-1"), {
+			message: FRESH_COUNT_MISSING_MESSAGE,
+		});
+	});
+});
+
+describe("awaitFreshMailboxCount", () => {
+	it("resolves with the count a round stamped past the baseline", async () => {
+		const responses = [[reading(0, 100)], [reading(0, 100)], [reading(3, 200)]];
+		let call = 0;
+		const outcome = await awaitFreshMailboxCount({
+			mailboxId: "mbx-1",
+			since: 100,
+			readMailboxes: async () => responses[call++] as MailboxCountReading[],
+			delay: noDelay,
+		});
+		assert.deepEqual(outcome, { status: "fresh", messageCount: 3 });
+		assert.equal(call, 3);
+	});
+
+	it("never reports a count from a round older than the baseline", async () => {
+		// The stamp stands still — the folder was never re-read, so the zero
+		// sitting in the row is exactly the stale count that must not be trusted.
+		const outcome = await awaitFreshMailboxCount({
+			mailboxId: "mbx-1",
+			since: 100,
+			readMailboxes: async () => [reading(0, 100)],
+			delay: noDelay,
+			now: impatientClock(),
+		});
+		assert.deepEqual(outcome, { status: "pending" });
+	});
+
+	it("resumes against the same baseline and then reports the count", async () => {
+		let stamp = 100;
+		const readMailboxes = async () => [reading(2, stamp)];
+		const first = await awaitFreshMailboxCount({
+			mailboxId: "mbx-1",
+			since: 100,
+			readMailboxes,
+			delay: noDelay,
+			now: impatientClock(),
+		});
+		assert.deepEqual(first, { status: "pending" });
+
+		stamp = 300;
+		const second = await awaitFreshMailboxCount({
+			mailboxId: "mbx-1",
+			since: 100,
+			readMailboxes,
+			delay: noDelay,
+			now: impatientClock(),
+		});
+		assert.deepEqual(second, { status: "fresh", messageCount: 2 });
+	});
+
+	it("refuses a folder the account no longer lists", async () => {
+		await assert.rejects(
+			awaitFreshMailboxCount({
+				mailboxId: "mbx-1",
+				since: 100,
+				readMailboxes: async () => [],
+				delay: noDelay,
+			}),
+			{ message: FRESH_COUNT_MISSING_MESSAGE },
+		);
+	});
+
+	it("propagates a failed read rather than counting it as zero", async () => {
+		await assert.rejects(
+			awaitFreshMailboxCount({
+				mailboxId: "mbx-1",
+				since: 100,
+				readMailboxes: async () => {
+					throw new Error("sync status 500");
+				},
+				delay: noDelay,
+			}),
+			{ message: "sync status 500" },
+		);
+	});
+
+	it("stops on abort and never reports a count", async () => {
+		const controller = new AbortController();
+		let call = 0;
+		controller.abort();
+		await assert.rejects(
+			awaitFreshMailboxCount({
+				mailboxId: "mbx-1",
+				since: 100,
+				readMailboxes: async () => {
+					call += 1;
+					return [reading(0, 200)];
+				},
+				signal: controller.signal,
+				delay: noDelay,
+			}),
+		);
+		assert.equal(call, 0, "an aborted wait reads nothing");
+	});
+});

package/src/lib/fresh-mailbox-count.ts

@@ -0,0 +1,114 @@
+import { abortableDelay } from "./mailbox-sync-wait";
+
+/**
+ * How many messages a folder holds *on the mail server*, rather than how many
+ * the last sync round left in the local row.
+ *
+ * Every count the client can read — the mailbox row's `messageCount`, and so
+ * the folder list and the sync-status projection over it — is whatever the last
+ * round wrote. Mail that arrived since is invisible in it, which is fine for a
+ * badge and fatal for a delete: `deleteMailbox` takes the folder's mail with it
+ * and IMAP has no undo.
+ *
+ * So the count is taken from a round asked for on the spot: trigger a sync,
+ * then wait for the folder's `lastSyncedAt` to advance past the stamp read
+ * before the trigger, and read the count that round wrote alongside it (every
+ * message-sync round writes both from the same IMAP STATUS).
+ *
+ * What the advancing stamp proves is that *some* round's write landed after the
+ * baseline read — not necessarily the round this triggered. A round already in
+ * flight can land first and satisfy the wait. That is accepted: its STATUS was
+ * taken within milliseconds of the baseline, and the error it can carry is a
+ * count from a moment too early, which either agrees with the trigger's round
+ * or reports mail the folder had and the delete then refuses. The mistake lands
+ * on the side of not deleting.
+ *
+ * Nothing here decides on a count read before the trigger, and every way out
+ * other than an advanced stamp throws or reports `pending`: a folder missing
+ * from the account, a failed read, an aborted wait. Uncertainty about what a
+ * folder holds is never permission to delete it.
+ */
+
+/** The read fields the wait needs off a sync-status entry. */
+export interface MailboxCountReading {
+	mailboxId: string;
+	messagesTotal: number;
+	lastSyncedAt?: number;
+}
+
+/** A count from a round that reported after the baseline, or no round yet. */
+export type FreshCountOutcome =
+	| { status: "fresh"; messageCount: number }
+	| { status: "pending" };
+
+export interface AwaitFreshMailboxCountOptions {
+	/** Reads every mailbox's sync-status entry; called once per poll. */
+	readMailboxes: () => Promise<readonly MailboxCountReading[]>;
+	/** The folder to count. */
+	mailboxId: string;
+	/** The folder's `lastSyncedAt` as read before the sync was triggered. */
+	since: number;
+	/** Aborts the wait; a round that lands afterwards resolves nothing. */
+	signal?: AbortSignal;
+	/** How long this stretch of waiting runs before reporting `pending`. */
+	segmentMs?: number;
+	pollIntervalMs?: number;
+	/** Injectable clock/sleep for tests. */
+	delay?: (ms: number, signal?: AbortSignal) => Promise<void>;
+	now?: () => number;
+}
+
+/**
+ * How long one stretch of waiting runs before handing the decision back to the
+ * user. An explicit sync fans the whole account out on one FIFO group with
+ * INBOX first, so a folder on a large account can sit behind minutes of other
+ * mailboxes: this is not long enough to conclude anything, only long enough
+ * that someone watching a spinner deserves to be asked whether to keep waiting.
+ */
+export const FRESH_COUNT_SEGMENT_MS = 120_000;
+export const FRESH_COUNT_POLL_INTERVAL_MS = 2_000;
+
+export const FRESH_COUNT_MISSING_MESSAGE =
+	"This folder is no longer in the account's folder list, so nothing was deleted.";
+
+const entryFor = (
+	mailboxes: readonly MailboxCountReading[],
+	mailboxId: string,
+): MailboxCountReading => {
+	const entry = mailboxes.find((mailbox) => mailbox.mailboxId === mailboxId);
+	if (!entry) throw new Error(FRESH_COUNT_MISSING_MESSAGE);
+	return entry;
+};
+
+/** The folder's last sync stamp, or a refusal when the account does not list it. */
+export const mailboxSyncStamp = (
+	mailboxes: readonly MailboxCountReading[],
+	mailboxId: string,
+): number => entryFor(mailboxes, mailboxId).lastSyncedAt ?? 0;
+
+/**
+ * Poll for one segment. Resolves `fresh` with the count once a round reports
+ * past `since`, `pending` when the segment runs out with the folder still
+ * unreported — the caller asks the user whether to wait on, and calling again
+ * with the same `since` resumes without triggering a second round.
+ */
+export async function awaitFreshMailboxCount({
+	readMailboxes,
+	mailboxId,
+	since,
+	signal,
+	segmentMs = FRESH_COUNT_SEGMENT_MS,
+	pollIntervalMs = FRESH_COUNT_POLL_INTERVAL_MS,
+	delay = abortableDelay,
+	now = Date.now,
+}: AwaitFreshMailboxCountOptions): Promise<FreshCountOutcome> {
+	const deadline = now() + segmentMs;
+	for (;;) {
+		signal?.throwIfAborted();
+		const entry = entryFor(await readMailboxes(), mailboxId);
+		if ((entry.lastSyncedAt ?? 0) > since)
+			return { status: "fresh", messageCount: entry.messagesTotal };
+		if (now() >= deadline) return { status: "pending" };
+		await delay(pollIntervalMs, signal);
+	}
+}

package/src/lib/mailbox-sync-wait.ts

@@ -50,7 +50,11 @@ export const MAILBOX_SYNC_FAILED_MESSAGE =
 export const MAILBOX_SYNC_TIMEOUT_MESSAGE =
 	"The folder was created but the mail server hasn't confirmed it yet, so nothing was attached to it. It's in your folder list — try again in a moment.";
 
-const defaultDelay = (ms: number, signal?: AbortSignal): Promise<void> =>
+/** `setTimeout` that rejects with the signal's reason instead of outliving it. */
+export const abortableDelay = (
+	ms: number,
+	signal?: AbortSignal,
+): Promise<void> =>
 	new Promise((resolve, reject) => {
 		if (signal?.aborted) {
 			reject(signal.reason);
@@ -81,7 +85,7 @@ export async function waitForMailboxSynced<T extends MailboxSyncSignal>({
 	signal,
 	timeoutMs = MAILBOX_SYNC_TIMEOUT_MS,
 	pollIntervalMs = MAILBOX_SYNC_POLL_INTERVAL_MS,
-	delay = defaultDelay,
+	delay = abortableDelay,
 	now = Date.now,
 }: WaitForMailboxSyncedOptions<T>): Promise<T> {
 	const deadline = now() + timeoutMs;

package/src/lib/move-targets.test.ts

@@ -214,3 +214,22 @@ describe("buildMoveTargets — Outbox locale exclusion (#290)", () => {
 		assert.deepStrictEqual(ids, ["custom", "inbox", "outboxy", "trash"]);
 	});
 });
+
+describe("buildMoveTargets — the server’s own delimiter (#877)", () => {
+	test("orders and filters by the leaf under a dot-delimited namespace", () => {
+		const dotted = (mailboxId: string, fullPath: string) =>
+			make({ mailboxId, fullPath, hierarchyDelimiter: "." });
+		const result = buildMoveTargets(
+			[
+				dotted("beta", "INBOX.Projects.Beta"),
+				dotted("outbox", "INBOX.Outbox"),
+				dotted("alpha", "INBOX.Zoo.Alpha"),
+			],
+			[],
+		);
+		assert.deepStrictEqual(
+			result.map((mailbox) => mailbox.mailboxId),
+			["alpha", "beta"],
+		);
+	});
+});