@remit/mailbox-service 0.0.112 → 0.0.113

package/src/placement-move-terminal.ts

@@ -1,145 +0,0 @@
-import type { IMessageRepository, MessageItem } from "@remit/data-ports";
-import { MessageMutation, MessageSyncStatus } from "@remit/domain-enums";
-import { isMessageGoneFromOpenMailbox } from "./message-presence.js";
-import type { PlacementMoveLogger } from "./placement-move.js";
-import {
-	type RestoreSourcePlacementDeps,
-	restoreSourcePlacement,
-} from "./restore-source-placement.js";
-import type { IImapConnection } from "./types.js";
-
-export interface ResolveExhaustedPlacementMoveDeps {
-	messageService: Pick<IMessageRepository, "deleteIfPlacement"> &
-		RestoreSourcePlacementDeps["messageService"];
-	threadMessageService: RestoreSourcePlacementDeps["threadMessageService"];
-	markerService: { delete(messageId: string): Promise<void> };
-	log: PlacementMoveLogger;
-}
-
-export interface ResolveExhaustedPlacementMoveInput {
-	/** Where the row stood when the caller read it; the delete holds only while it still does. */
-	placement: Pick<MessageItem, "status" | "mailboxId" | "uid">;
-	accountId: string;
-	accountConfigId: string;
-	messageId: string;
-	uid: number;
-	sourceMailboxId: string;
-	sourceMailboxPath: string;
-	getConnection: () => Promise<IImapConnection>;
-}
-
-export type PlacementMoveTerminalOutcome = "reconciled" | "broken";
-
-export interface ResolveExhaustedPlacementMoveResult {
-	outcome: PlacementMoveTerminalOutcome;
-}
-
-/**
- * Resolve a PLACEMENT_MOVE_PUSH failure that has exhausted the placement-move
- * queue's redelivery budget into exactly one of two terminal outcomes,
- * mirroring `resolveExhaustedBodySyncFailures` (#1270) for the same failure
- * taxonomy (epic #1281 invariant 3) — no third, softer outcome.
- *
- * 1. RECONCILED (expected) — the message no longer exists at its pending-move
- *    source on IMAP, confirmed by {@link isMessageGoneFromOpenMailbox} rather
- *    than by a FETCH coming back empty. Per invariant 2, an external delete
- *    supersedes the marker entirely: the marker is dropped and the stale
- *    Message/ThreadMessage rows are deleted via
- *    `deleteIfPlacement`. This is also the
- *    outcome for the (rarer, functionally indistinguishable from here) case
- *    where a foreign client moved the message elsewhere — either way, our
- *    prediction no longer holds, and the marker cannot be honoured. Metric
- *    only, no alarm — routine.
- * 2. BROKEN — the message still exists at the source, but the move keeps
- *    failing. This indicates broken code or a broken account (issue #1271),
- *    not a transient blip. The row is put back on the source pair the server
- *    has just confirmed, exactly as the move and delete resolvers do, and the
- *    marker goes with it: an auto-file whose push gave up must not leave
- *    `moving` plus the destination folder plus the source's uid standing
- *    forever, because that pair refuses every later delete and move with a
- *    409, blocks the sighting repair, and nothing else clears it. The failure
- *    is an operator's to read, so it lives in the `alert`-shaped log entry and
- *    the alarm on it — not in a row the user's own mail is stuck behind.
- *    Never re-thrown (terminal — the caller acks either way, since retrying a
- *    stale or permanently-broken move can never succeed).
- *
- * An operator reading `placement_move_failed` should know one case where the
- * message is not actually at the source: a message another client expunged
- * mid-session can answer an empty FETCH while the server still lists its UID
- * in SEARCH, until it is allowed to send the untagged EXPUNGE. That message
- * lands in BROKEN, and BROKEN is terminal — the alert stands until someone
- * clears it, and the row goes back to a source the message may already have
- * left. The reverse mistake deletes live mail, so the cost is paid
- * deliberately: a stale alert over a row the next sync re-points is
- * recoverable, a deleted message is not.
- */
-export const resolveExhaustedPlacementMoveFailure = async (
-	deps: ResolveExhaustedPlacementMoveDeps,
-	input: ResolveExhaustedPlacementMoveInput,
-): Promise<ResolveExhaustedPlacementMoveResult> => {
-	const {
-		accountId,
-		accountConfigId,
-		messageId,
-		uid,
-		sourceMailboxId,
-		sourceMailboxPath,
-		getConnection,
-	} = input;
-
-	const connection = await getConnection();
-	await connection.openBox(sourceMailboxPath);
-
-	if (await isMessageGoneFromOpenMailbox(connection, uid)) {
-		await deps.markerService.delete(messageId);
-		const reconciled = await deps.messageService.deleteIfPlacement(
-			messageId,
-			input.placement,
-		);
-		deps.log.info(
-			{
-				metric: "placement_move_stale_row_reconciled",
-				accountId,
-				accountConfigId,
-				messageId,
-				uid,
-				sourceMailboxPath,
-				reconciled,
-			},
-			"Message no longer at its pending-move source after retry exhaustion (external delete or move); marker dropped, stale row reconciled",
-		);
-		return { outcome: "reconciled" };
-	}
-
-	// The row first, the marker second. The marker is the operator's evidence
-	// that this move still owed IMAP a push; dropping it before the restore
-	// means a restore that throws leaves the row stuck `moving` with nothing
-	// left to say why.
-	await restoreSourcePlacement(deps, {
-		accountConfigId,
-		messageId,
-		sourceMailboxId,
-		uid,
-		// No give-up marker: this move is Remit's own classification filing, not
-		// something the user asked for, so a per-message "your move failed" would
-		// report a failure against an intent nobody formed. The alert below is the
-		// whole surface, and it is an operator's.
-		syncStatus: MessageSyncStatus.synced,
-		abandonedMutation: MessageMutation.none,
-	});
-	await deps.markerService.delete(messageId);
-
-	deps.log.error(
-		{
-			alert: "placement_move_failed",
-			accountId,
-			accountConfigId,
-			messageId,
-			uid,
-			sourceMailboxId,
-			sourceMailboxPath,
-		},
-		"Placement move could not be pushed to IMAP after retry exhaustion; message still exists at its source — row restored to the source pair, marker dropped, alert left for operator investigation",
-	);
-	return { outcome: "broken" };
-};

package/src/placement-move.ts

@@ -1,363 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
-import type {
-	IAddressRepository,
-	IMailboxRepository,
-	IMailboxSpecialUseRepository,
-	IMessagePlacementMoveRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-} from "@remit/data-ports";
-import {
-	MessageMutation,
-	MessageStatus,
-	MessageSyncStatus,
-} from "@remit/domain-enums";
-import { createQueueProducer } from "@remit/sqs-client/producer";
-import {
-	isPlacementUnsettled,
-	waitForPlacementToSettle,
-} from "./placement-settled.js";
-
-/**
- * Event the reconciler (imap-worker `handlePlacementMovePush`) drains. Carries
- * ONLY our own message id — never a UID (epic #1281 invariant 1). The UID is
- * resolved fresh from the Message row at push time, so the event stays valid
- * across any amount of queue delay or an unrelated UIDVALIDITY rebuild
- * (#1272).
- */
-export interface PlacementMovePushEvent {
-	type: "PLACEMENT_MOVE_PUSH";
-	eventId: string;
-	timestamp: number;
-	accountId: string;
-	accountConfigId: string;
-	messageId: string;
-}
-
-/** Whether a filing happened. `refused` names a destination outside the message's account. */
-export type PlacementMoveOutcome = "filed" | "skipped" | "refused";
-
-export interface PlacementMoveLogger {
-	info(obj: Record<string, unknown>, msg: string): void;
-	error(obj: Record<string, unknown>, msg: string): void;
-}
-
-const noopLogger: PlacementMoveLogger = {
-	info: () => {},
-	error: () => {},
-};
-
-export interface PlacementMoveConfig {
-	messageService: IMessageRepository;
-	threadMessageService: IThreadMessageRepository;
-	markerService: IMessagePlacementMoveRepository;
-	addressService: IAddressRepository;
-	/**
-	 * Required, not optional: this mover carries automatic spam placement, and
-	 * one built without the folder-role seam would silently leave the sender of
-	 * every auto-filed spam suggestible in the compose picker.
-	 */
-	mailboxSpecialUseService: IMailboxSpecialUseRepository;
-	mailboxService: Pick<IMailboxRepository, "resolveAccountId">;
-	sqsQueueUrl: string;
-	sqsEndpoint?: string;
-	logger?: PlacementMoveLogger;
-	moveSettleTimeoutMs?: number;
-	moveSettlePollMs?: number;
-}
-
-const DEFAULT_MOVE_SETTLE_TIMEOUT_MS = 5_000;
-const DEFAULT_MOVE_SETTLE_POLL_MS = 250;
-
-/**
- * Local-first mover for a classification-driven placement move (issue #1271,
- * epic #1281). Distinct from {@link MessageMoveService} (user-initiated
- * moves/deletes/copies), which is untouched by this fix — the epic's UID
- * staleness invariant (1) only applies to the NEW reconciler this class
- * feeds; generalizing it to every move type is out of scope here.
- *
- * `moveMessage` matches {@link MessageMoveService.moveMessage}'s signature so
- * `BodySyncService`'s existing rescue/demote call site and its tests need no
- * shape changes beyond the dependency's name.
- *
- * Ordering is the fix: every step below (marker, ThreadMessage, Message row,
- * SQS enqueue) completes — or the whole call rejects — BEFORE the caller
- * (`BodySyncService.storeStreamedBody`) writes `bodyStorageKey`. A rejection
- * here therefore always happens before the body-sync skip-guard can trip, so
- * a retry reprocesses the message from scratch. Nothing here is swallowed —
- * let it crash, same as any other infra failure (an SQS enqueue failure is a
- * serious operational failure, not a routine blip: it propagates so a
- * repeated failure reaches the alarmed message-mgmt DLQ, never absorbed).
- *
- * Recovery is driven by the marker's explicit state engine (`pending ->
- * queued -> processing -> processed`, `MessagePlacementMoveState`), not by
- * comparing the message's current location against the requested
- * destination — that comparison alone cannot tell "already confirmed" apart
- * from "local move landed but the enqueue never did" (the defect this issue
- * originally fixes). A retry always re-fetches the marker and drives it
- * forward from whichever state it is actually in.
- */
-export class PlacementMoveService {
-	private messageService: IMessageRepository;
-	private threadMessageService: IThreadMessageRepository;
-	private markerService: IMessagePlacementMoveRepository;
-	private addressService: IAddressRepository;
-	private mailboxSpecialUseService: IMailboxSpecialUseRepository;
-	private mailboxService: Pick<IMailboxRepository, "resolveAccountId">;
-	private sqs: SQSClient;
-	private queueUrl: string;
-	private log: PlacementMoveLogger;
-	private moveSettleTimeoutMs: number;
-	private moveSettlePollMs: number;
-
-	constructor(config: PlacementMoveConfig) {
-		this.messageService = config.messageService;
-		this.threadMessageService = config.threadMessageService;
-		this.markerService = config.markerService;
-		this.addressService = config.addressService;
-		this.mailboxSpecialUseService = config.mailboxSpecialUseService;
-		this.mailboxService = config.mailboxService;
-		this.queueUrl = config.sqsQueueUrl;
-		this.log = config.logger ?? noopLogger;
-		this.moveSettleTimeoutMs =
-			config.moveSettleTimeoutMs ?? DEFAULT_MOVE_SETTLE_TIMEOUT_MS;
-		this.moveSettlePollMs =
-			config.moveSettlePollMs ?? DEFAULT_MOVE_SETTLE_POLL_MS;
-		this.sqs = createQueueProducer({
-			queueUrl: config.sqsQueueUrl,
-			endpoint: config.sqsEndpoint,
-		});
-	}
-
-	moveMessage = async (
-		accountConfigId: string,
-		messageId: string,
-		destinationMailboxId: string,
-		accountId: string,
-	): Promise<PlacementMoveOutcome> => {
-		let message = await this.messageService.get(messageId);
-
-		// Recovery: a marker already exists for THIS message and destination —
-		// from an earlier (possibly partially-failed) call. The marker's STATE,
-		// not a comparison against the message's current location, decides what
-		// happens next (PR #1289 review finding 1 + design amendment: an
-		// explicit pending -> queued -> processing -> processed engine).
-		const existingMarker = await this.markerService.find(messageId);
-		if (
-			existingMarker &&
-			existingMarker.destinationMailboxId === destinationMailboxId
-		) {
-			if (existingMarker.state === "pending") {
-				// Local move + marker already committed; only the enqueue is
-				// missing (or a further retry after the enqueue itself failed
-				// again). Drive the SAME marker forward — never re-derive the
-				// local move, which already happened.
-				await this.enqueuePush({ accountId, accountConfigId, messageId });
-				await this.markerService.updateState(messageId, "queued");
-				this.log.info(
-					{ messageId, accountId, destinationMailboxId },
-					"Pending marker survived an earlier enqueue failure; re-enqueued and advanced to queued",
-				);
-			}
-			// queued / processing / processed already has its own driver in
-			// flight (the SQS message, or the reconciler currently running) —
-			// nothing to do here either way.
-			return "filed";
-		}
-
-		// A different destination, decided while an earlier move is still
-		// unconfirmed (issue #496): the row names that move's destination but its
-		// `uid` still belongs to the folder before it, so a marker bound to the
-		// pair as it stands sends the reconciler to move the destination folder's
-		// OWN message at that uid. Wait for the earlier move to confirm and bind
-		// to the settled row (docs/architecture/imap-mutations.md R2). Blocking is
-		// cheap — a move settles in well under a second — and on timeout the
-		// dependent write is simply not made.
-		// A delete in flight is not a move to wait out: the user has asked for the
-		// message to go, and a classification filing behind it has nothing left to
-		// file. Skipping is the answer, and it is a clean one — throwing would
-		// burn the ceiling and then drive an ordinary sequence toward the DLQ.
-		if (message.status === MessageStatus.deleting) {
-			this.log.info(
-				{ messageId, accountId, destinationMailboxId },
-				"Placement move not applied: this message is being deleted",
-			);
-			return "skipped";
-		}
-
-		if (isPlacementUnsettled(message)) {
-			message = await waitForPlacementToSettle(this.messageService, messageId, {
-				timeoutMs: this.moveSettleTimeoutMs,
-				pollMs: this.moveSettlePollMs,
-			});
-			if (message.status === MessageStatus.deleting) {
-				this.log.info(
-					{ messageId, accountId, destinationMailboxId },
-					"Placement move not applied: a delete claimed this message while the earlier move settled",
-				);
-				return "skipped";
-			}
-			if (isPlacementUnsettled(message)) {
-				throw new Error(
-					`Placement move for ${messageId} to ${destinationMailboxId} not applied: an earlier move has not settled`,
-				);
-			}
-		}
-
-		const sourceMailboxId = message.mailboxId;
-
-		// Genuine no-op: nothing pending for this destination, and the message
-		// is already there (a duplicate verdict recomputed after a confirmed
-		// move).
-		if (sourceMailboxId === destinationMailboxId) return "skipped";
-
-		// IMAP has no MOVE between accounts, so a filing into a folder this
-		// account does not own would only ever be handed back.
-		if (
-			(await this.mailboxService.resolveAccountId(destinationMailboxId)) !==
-			accountId
-		) {
-			this.log.error(
-				{
-					alert: "placement_move_foreign_folder",
-					messageId,
-					accountId,
-					sourceMailboxId,
-					destinationMailboxId,
-				},
-				"Placement move refused: the destination is not a folder of this message's account",
-			);
-			return "refused";
-		}
-
-		// Fresh move. Strictly sequential — nothing here is parallel: the local
-		// move (marker + ThreadMessage + Message row) fully commits BEFORE the
-		// queue kick runs. `put` is idempotent and always resets `state` back to
-		// `pending`, since a fresh decision starts a new lifecycle regardless of
-		// what a stale row (different destination) held.
-		await this.markerService.put({
-			messageId,
-			accountId,
-			accountConfigId,
-			sourceMailboxId,
-			destinationMailboxId,
-		});
-
-		// The Message row first, the listing row after it — the order the user
-		// move and the delete already use. A transition off the row the wait above
-		// settled on (imap-mutations R3): this lane rides a standard queue that
-		// the account's FIFO group does not order, so a user's own move or delete
-		// can claim the row between that read and this write, and writing anyway
-		// would stamp Remit's classification over a folder the user just chose,
-		// with the old uid attached.
-		//
-		// Writing the listing row first meant a loser left the two disagreeing —
-		// the listing showing the classification folder while the Message row sat
-		// where the winner put it — and nothing routine reconciles that.
-		//
-		// The marker goes with the loss. It is the record that a move owes IMAP a
-		// push, and this move is not happening, so leaving it would send the
-		// reconciler after a placement nobody wrote and would inflate the folder
-		// counts it predicts.
-		const filed = await this.messageService.transitionPlacement(
-			messageId,
-			{
-				status: MessageStatus.active,
-				mailboxId: sourceMailboxId,
-				uid: message.uid,
-			},
-			{
-				mailboxId: destinationMailboxId,
-				status: MessageStatus.moving,
-				syncStatus: MessageSyncStatus.pending,
-				abandonedMutation: MessageMutation.none,
-				originalMailboxId: sourceMailboxId,
-				originalUid: message.uid,
-			},
-		);
-		if (!filed) {
-			await this.markerService.delete(messageId);
-			this.log.info(
-				{ messageId, accountId, sourceMailboxId, destinationMailboxId },
-				"Placement move not applied: something else claimed this message's placement first",
-			);
-			return "skipped";
-		}
-
-		await this.updateThreadMessageMailbox(
-			accountConfigId,
-			messageId,
-			destinationMailboxId,
-		);
-
-		await this.addressService.reconcileJunkOnlyForMessage(
-			messageId,
-			await this.mailboxSpecialUseService.resolveJunkRolesForConfig(
-				accountConfigId,
-			),
-		);
-
-		// The queue kick is a serious operational step, not a routine one — a
-		// failure here MUST propagate (never swallowed): the marker stays
-		// `pending`, the surrounding body-sync call fails, SQS redelivers, and
-		// a repeated failure reaches the alarmed message-mgmt DLQ. The state
-		// engine makes this *recoverable* (the recovery branch above drives a
-		// surviving `pending` marker forward on the next call) — it must never
-		// make it *quiet*.
-		await this.enqueuePush({ accountId, accountConfigId, messageId });
-		await this.markerService.updateState(messageId, "queued");
-
-		this.log.info(
-			{ messageId, accountId, sourceMailboxId, destinationMailboxId },
-			"Placement move applied locally; pending marker queued for IMAP push",
-		);
-		return "filed";
-	};
-
-	private updateThreadMessageMailbox = async (
-		accountConfigId: string,
-		messageId: string,
-		destinationMailboxId: string,
-	): Promise<void> => {
-		const threadMessage = await this.threadMessageService.getByMessageId(
-			accountConfigId,
-			messageId,
-		);
-
-		await this.threadMessageService.update(
-			threadMessage.accountConfigId,
-			threadMessage.threadMessageId,
-			{ mailboxId: destinationMailboxId },
-			{
-				composites: {
-					sentDate: threadMessage.sentDate,
-					mailboxId: threadMessage.mailboxId,
-					isRead: threadMessage.isRead,
-					isDeleted: threadMessage.isDeleted,
-					hasStars: threadMessage.hasStars,
-					hasAttachment: threadMessage.hasAttachment,
-				},
-			},
-		);
-	};
-
-	private enqueuePush = async (params: {
-		accountId: string;
-		accountConfigId: string;
-		messageId: string;
-	}): Promise<void> => {
-		const event: PlacementMovePushEvent = {
-			type: "PLACEMENT_MOVE_PUSH",
-			eventId: randomUUID(),
-			timestamp: Date.now(),
-			...params,
-		};
-		await this.sqs.send(
-			new SendMessageCommand({
-				QueueUrl: this.queueUrl,
-				MessageBody: JSON.stringify(event),
-			}),
-		);
-	};
-}

package/src/placement-settled.test.ts

@@ -1,147 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import type { MessageItem } from "@remit/data-ports";
-import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
-import { carriesForeignUid, placementBindingOf } from "./placement-settled.js";
-
-/**
- * Pins `placementBindingOf` directly. It is the guard #1098/#1143 depend on and
- * only end-to-end specs covered it, so a change made for the client's benefit
- * could have moved it without anything going red.
- *
- * Note what these cases say about `syncStatus`: `failed` is a transient attempt
- * with a redelivery behind it, so a foreign-uid row carrying it is `in_flight`
- * and gets the settle ceiling. Only `abandoned` — the give-up value of the
- * placement state model (imap-mutations R3) — refuses outright.
- */
-const row = (over: Partial<MessageItem>): MessageItem =>
-	({
-		messageId: "m-1",
-		mailboxId: "mbx-dest",
-		uid: 7,
-		status: MessageStatus.moving,
-		syncStatus: MessageSyncStatus.pending,
-		originalMailboxId: "mbx-src",
-		originalUid: 7,
-		...over,
-	}) as unknown as MessageItem;
-
-describe("placementBindingOf", () => {
-	test("a settled row binds consistently", () => {
-		assert.equal(
-			placementBindingOf(row({ status: MessageStatus.active })),
-			"consistent",
-		);
-	});
-
-	test("a row whose uid still names the source is in flight", () => {
-		assert.equal(placementBindingOf(row({})), "in_flight");
-	});
-
-	/**
-	 * A give-up cannot reach this pair. `abandoned` is written only alongside
-	 * `active` or `deleted`, on a row already put back on a placement the server
-	 * confirmed, so the binding it produces is `consistent` — there is no
-	 * give-up member here to return, and no dependent mutation is refused on
-	 * account of one.
-	 */
-	test("a give-up never presents as a foreign-uid row at all", () => {
-		assert.equal(
-			placementBindingOf(
-				row({
-					status: MessageStatus.active,
-					syncStatus: MessageSyncStatus.abandoned,
-					mailboxId: "mbx-src",
-				}),
-			),
-			"consistent",
-		);
-	});
-
-	test("`failed` on a foreign-uid row is mid-retry, so it waits rather than refusing", () => {
-		assert.equal(
-			placementBindingOf(row({ syncStatus: MessageSyncStatus.failed })),
-			"in_flight",
-		);
-	});
-
-	// R3's state table calls `deleting` in flight exactly as `moving` is: a
-	// delete points the row at Trash with the source's uid, so a dependent
-	// mutation reading it resolves the same mismatched pair.
-	test("a delete in flight is unsettled, not settled", () => {
-		assert.equal(
-			placementBindingOf(row({ status: MessageStatus.deleting })),
-			"in_flight",
-		);
-	});
-
-	test("a moving row that was never moved binds consistently", () => {
-		assert.equal(
-			placementBindingOf(
-				row({ originalUid: undefined, originalMailboxId: undefined }),
-			),
-			"consistent",
-		);
-	});
-
-	test("a moving row whose uid has been repointed binds consistently", () => {
-		assert.equal(placementBindingOf(row({ uid: 42 })), "consistent");
-	});
-
-	test("`failed` alone, with no foreign uid, is still consistent", () => {
-		assert.equal(
-			placementBindingOf(
-				row({
-					status: MessageStatus.active,
-					syncStatus: MessageSyncStatus.failed,
-				}),
-			),
-			"consistent",
-		);
-	});
-});
-
-/**
- * The same question with the `status` gate off, for callers that resolve a uid
- * off a row some other operation may have re-marked on its way past (#1217).
- */
-describe("carriesForeignUid", () => {
-	test("holds whatever an operation has since written to `status`", () => {
-		for (const status of [
-			MessageStatus.moving,
-			MessageStatus.deleting,
-			MessageStatus.active,
-		]) {
-			assert.equal(carriesForeignUid(row({ status })), true, status);
-		}
-	});
-
-	test("is false once `updateUid` settles the move", () => {
-		// The settle writes the destination's own uid and drops `originalUid` in
-		// the same statement, so a destination counter that hands back the
-		// source's number cannot leave the row reading foreign forever.
-		assert.equal(
-			carriesForeignUid(
-				row({
-					status: MessageStatus.active,
-					syncStatus: MessageSyncStatus.synced,
-					originalUid: undefined,
-				}),
-			),
-			false,
-		);
-	});
-
-	test("is false for a row that was never moved", () => {
-		assert.equal(
-			carriesForeignUid(
-				row({ originalUid: undefined, originalMailboxId: undefined }),
-			),
-			false,
-		);
-	});
-
-	test("is false once a restore points the row back at that folder", () => {
-		assert.equal(carriesForeignUid(row({ mailboxId: "mbx-src" })), false);
-	});
-});