@remit/data-ports 0.0.83 → 0.0.85

package/src/interfaces/thread-message.ts

@@ -1,264 +0,0 @@
-import type {
-	CreateThreadMessageInput,
-	ResultList,
-	SearchOptions,
-	ThreadMessageFieldTerm,
-	ThreadMessageItem,
-	UpdateThreadMessageInput,
-} from "../types.js";
-
-export interface IThreadMessageRepository {
-	create(input: CreateThreadMessageInput): Promise<ThreadMessageItem>;
-	get(
-		accountConfigId: string,
-		threadMessageId: string,
-	): Promise<ThreadMessageItem>;
-	get(
-		accountConfigId: string,
-		threadMessageIds: string[],
-	): Promise<ThreadMessageItem[]>;
-	update(
-		accountConfigId: string,
-		threadMessageId: string,
-		input: UpdateThreadMessageInput,
-		options?: {
-			composites?: {
-				sentDate?: number;
-				mailboxId?: string;
-				isRead?: boolean;
-				isDeleted?: boolean;
-				hasStars?: boolean;
-				hasAttachment?: boolean;
-			};
-		},
-	): Promise<ThreadMessageItem>;
-	delete(accountConfigId: string, threadMessageId: string): Promise<void>;
-	deleteMany(
-		keys: Array<{ accountConfigId: string; threadMessageId: string }>,
-	): Promise<void>;
-	listByAccount(
-		accountConfigId: string,
-		options?: { limit?: number; continuationToken?: string },
-	): Promise<ResultList<ThreadMessageItem>>;
-	listByDate(
-		accountConfigId: string,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			inboxMailboxIds?: Set<string>;
-			excludeDeleted?: boolean;
-			/**
-			 * Row criteria applied inside the query, so a page is a page of
-			 * matches however rare the criterion is. Filtering the rows a page
-			 * returned instead is what makes a listing look empty whenever the
-			 * matching mail sits below the newest page (#308).
-			 */
-			search?: SearchOptions;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	/**
-	 * Search rows for a config across every mailbox in `mailboxIds` — the
-	 * cross-account, cross-folder counterpart of `searchByMailbox`. A row whose
-	 * From matches any `query` term ranks above one that only mentions the
-	 * terms, and each tier runs in date order.
-	 *
-	 * The caller supplies the mailbox scope, so a search reaching Archive, Sent, Spam and
-	 * custom folders is a matter of which set is passed. An empty or absent
-	 * `mailboxIds` means no narrowing (every mailbox of the config), which is why
-	 * handlers pass an explicitly built set rather than relying on the default.
-	 *
-	 * Matching follows `searchByMailbox`: `query` splits on whitespace and every
-	 * term must match subject OR From, case-insensitively. `limit` is a page size
-	 * over MATCHES, clamped server-side, so a short page means the matches ran
-	 * out — never that a read window was exhausted.
-	 *
-	 * Rows are per mailbox, not per conversation: the same mail filed in two
-	 * folders is two rows sharing a `threadId`.
-	 */
-	searchByDate(
-		accountConfigId: string,
-		search: SearchOptions,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			mailboxIds?: Set<string>;
-			excludeDeleted?: boolean;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	/**
-	 * Rows of a config whose sender, subject or `List-Id` column matches a set
-	 * of substring terms, newest first, across every mailbox — the store-side
-	 * narrowing a rule back-apply reads with.
-	 *
-	 * The terms are evaluated in the query, so `limit` is a page size over
-	 * MATCHES and the scan reaches the whole config however old the matching
-	 * mail is. Paging a date-ordered listing and filtering the rows it returned
-	 * is what makes a rule for a quiet sender report a handful of matches on a
-	 * mailbox holding thousands (#459).
-	 *
-	 * `operator` combines the terms — `"and"` requires every one, `"or"` any.
-	 * An empty `terms` narrows nothing under either operator: the whole config,
-	 * newest first.
-	 *
-	 * A term an implementation cannot evaluate faithfully is IGNORED, never
-	 * approximated: the result may be wider than the terms asked for and never
-	 * narrower, so the caller's own matcher stays the judge.
-	 *
-	 * Matching follows `searchByMailbox`: accent- and case-insensitive
-	 * substring over the same folded columns.
-	 *
-	 * Rows are per mailbox, not per conversation: the same mail filed in two
-	 * folders is two rows sharing a `threadId`. `mailboxIds` narrows the rows
-	 * to those folders; omitting it reads every mailbox.
-	 */
-	listByFieldTerms(
-		accountConfigId: string,
-		terms: readonly ThreadMessageFieldTerm[],
-		options?: {
-			operator?: "and" | "or";
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			excludeDeleted?: boolean;
-			mailboxIds?: readonly string[];
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	/**
-	 * List starred rows for a config, newest first, across every mailbox.
-	 *
-	 * Backed by the `byStarred` index (pk = accountConfigId, sk = hasStars +
-	 * sentDate). Starredness is read from `hasStars` — the boolean of record —
-	 * never from the presentation-only `star` colour. `mailboxIds` narrows the
-	 * result to a caller-supplied set (used to drop muted mailboxes and the
-	 * folders a star never surfaces from); omitting it returns every mailbox.
-	 *
-	 * Rows are per mailbox, not per conversation: the same mail filed in two
-	 * folders is two rows sharing a `threadId`. Callers that render one row per
-	 * conversation must collapse by `threadId` across the pages they have
-	 * accumulated — this cannot be done inside a single page.
-	 */
-	listByStarred(
-		accountConfigId: string,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			mailboxIds?: Set<string>;
-			excludeDeleted?: boolean;
-			/** Row criteria applied inside the query; see `listByDate`. */
-			search?: SearchOptions;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	/**
-	 * COUNT of matching CONVERSATIONS over the same predicate and the same
-	 * mailbox scope the three cross-account listing modes read with — the scoped
-	 * counterpart of `countByMailbox`.
-	 *
-	 * A page size bounds the rows a response carries and has no bearing on how
-	 * much matches, so a count returns no rows and is answered in full.
-	 *
-	 * Distinct on `threadId`, unlike `countByMailbox`, because the cross-account
-	 * listing is collapsed by thread before it is rendered: a row is per mailbox,
-	 * so one message reachable through a real folder and a virtual copy of it is
-	 * several rows, and two matching messages of one conversation are two more.
-	 */
-	countThreadsInScope(
-		accountConfigId: string,
-		search: SearchOptions,
-		options?: {
-			mailboxIds?: Set<string>;
-			excludeDeleted?: boolean;
-		},
-	): Promise<number>;
-	/**
-	 * Every message of a thread, across all mailboxes of the account. A
-	 * conversation spans INBOX, Sent and any folder its messages were filed
-	 * in, so this listing is deliberately not scoped to a mailbox (#46).
-	 *
-	 * Ordered by `sentDate` with `threadMessageId` breaking ties, ascending
-	 * unless `order` says otherwise — a conversation reads in the order it
-	 * happened (#81). Every implementation sorts in the query, so the order
-	 * holds across pages and not merely within one page.
-	 */
-	listByThread(
-		threadId: string,
-		accountConfigId: string,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			excludeDeleted?: boolean;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	findByMessageId(
-		accountConfigId: string,
-		messageId: string,
-	): Promise<ThreadMessageItem | null>;
-	findAllByMessageId(
-		accountConfigId: string,
-		messageId: string,
-	): Promise<ThreadMessageItem[]>;
-	getByMessageId(
-		accountConfigId: string,
-		messageId: string,
-	): Promise<ThreadMessageItem>;
-	listByMailbox(
-		accountConfigId: string,
-		mailboxId: string,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			attributes?: string[];
-			excludeDeleted?: boolean;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	countByThread(accountConfigId: string, threadId: string): Promise<number>;
-	searchByMailbox(
-		accountConfigId: string,
-		mailboxId: string,
-		search: SearchOptions,
-		options?: {
-			order?: "asc" | "desc";
-			count?: number;
-			continuationToken?: string;
-			excludeDeleted?: boolean;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	searchByMailboxWindow(
-		accountConfigId: string,
-		mailboxId: string,
-		search: SearchOptions,
-		options?: {
-			order?: "asc" | "desc";
-			limit?: number;
-			continuationToken?: string;
-			attributes?: string[];
-			excludeDeleted?: boolean;
-		},
-	): Promise<ResultList<ThreadMessageItem>>;
-	/**
-	 * COUNT of matching MESSAGES in one mailbox, under the same predicate
-	 * `searchByMailboxWindow` reads with — the per-mailbox counterpart of
-	 * `countThreadsInScope`, and not distinct on `threadId` because the listing
-	 * it answers for renders a row per message.
-	 *
-	 * The number is over the whole mailbox. No page size bounds it and no cursor
-	 * narrows it, so it does not shrink as the caller pages and does not change
-	 * when the page size does (#305). There is nothing to cap: the count is one
-	 * aggregate read that returns no rows.
-	 */
-	countByMailbox(
-		accountConfigId: string,
-		mailboxId: string,
-		search: SearchOptions,
-		options?: {
-			excludeDeleted?: boolean;
-			order?: "asc" | "desc";
-		},
-	): Promise<number>;
-	listAllByAccount(accountConfigId: string): Promise<ThreadMessageItem[]>;
-	deleteAllByAccount(accountConfigId: string): Promise<number>;
-}

package/src/interfaces/unit-of-work.ts

@@ -1,28 +0,0 @@
-import type { IAddressRepository } from "./address.js";
-import type { IEnvelopeRepository } from "./envelope.js";
-import type { IMessageRepository } from "./message.js";
-import type { IThreadMessageRepository } from "./thread-message.js";
-
-/**
- * The repositories a `saveMessage` write set touches, bound to a single unit of
- * work. On Postgres these are transaction-bound so every write — including the
- * transactional-outbox rows the message write appends — commits or rolls back
- * together.
- */
-export interface UnitOfWorkRepositories {
-	message: IMessageRepository;
-	envelope: IEnvelopeRepository;
-	address: IAddressRepository;
-	threadMessage: IThreadMessageRepository;
-}
-
-/**
- * Runs a set of related writes as one atomic unit. The callback receives
- * repositories bound to the unit of work; a throw rolls the whole set back.
- *
- * Backends without cross-entity transactions supply a pass-through
- * implementation that runs the callback against the plain repositories.
- */
-export interface IUnitOfWork {
-	transaction<T>(fn: (repos: UnitOfWorkRepositories) => Promise<T>): Promise<T>;
-}

package/src/mailbox-name.test.ts

@@ -1,106 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { mailboxLeafName, resolveMailboxByLeafName } from "./mailbox-name.js";
-
-const JUNK_NAMES = ["junk", "spam", "junk e-mail", "junk email", "bulk mail"];
-
-const mailbox = (
-	mailboxId: string,
-	fullPath: string,
-	hierarchyDelimiter = "/",
-) => ({ mailboxId, fullPath, hierarchyDelimiter });
-
-describe("resolveMailboxByLeafName", () => {
-	it("resolves a Junk folder nested under INBOX", () => {
-		// The layout that broke report-spam's name fallback: an INBOX-prefixed
-		// namespace where Junk is `INBOX/Spam`, which never equals "spam".
-		const found = resolveMailboxByLeafName(
-			[
-				mailbox("m-inbox", "INBOX"),
-				mailbox("m-spam", "INBOX/Spam"),
-				mailbox("m-sent", "INBOX/Sent"),
-			],
-			JUNK_NAMES,
-		);
-		assert.equal(found?.mailboxId, "m-spam");
-	});
-
-	it("resolves under a non-slash delimiter and a non-INBOX prefix", () => {
-		const found = resolveMailboxByLeafName(
-			[mailbox("m-junk", "Mail.Junk E-mail", ".")],
-			JUNK_NAMES,
-		);
-		assert.equal(found?.mailboxId, "m-junk");
-	});
-
-	it("treats a flat namespace with no delimiter as its own leaf", () => {
-		const found = resolveMailboxByLeafName(
-			[mailbox("m-junk", "Junk", "")],
-			JUNK_NAMES,
-		);
-		assert.equal(found?.mailboxId, "m-junk");
-	});
-
-	it("prefers the shallowest match over a deeper one", () => {
-		const found = resolveMailboxByLeafName(
-			[
-				mailbox("m-buried", "Archive/2019/Spam"),
-				mailbox("m-real", "INBOX/Junk"),
-			],
-			JUNK_NAMES,
-		);
-		assert.equal(found?.mailboxId, "m-real");
-	});
-
-	it("prefers the better name at equal depth", () => {
-		const found = resolveMailboxByLeafName(
-			[mailbox("m-bulk", "INBOX/Bulk Mail"), mailbox("m-junk", "INBOX/Junk")],
-			JUNK_NAMES,
-		);
-		assert.equal(found?.mailboxId, "m-junk");
-	});
-
-	it("answers null when no folder carries a conventional name", () => {
-		const found = resolveMailboxByLeafName(
-			[mailbox("m-inbox", "INBOX"), mailbox("m-work", "INBOX/Work")],
-			JUNK_NAMES,
-		);
-		assert.equal(found, null);
-	});
-});
-
-describe("mailboxLeafName", () => {
-	it("takes the leaf under a dot-delimited namespace", () => {
-		assert.equal(
-			mailboxLeafName({
-				fullPath: "INBOX.Projects.Q3",
-				hierarchyDelimiter: ".",
-			}),
-			"Q3",
-		);
-	});
-
-	it("takes the leaf under a slash-delimited namespace", () => {
-		assert.equal(
-			mailboxLeafName({
-				fullPath: "INBOX/Sent Messages",
-				hierarchyDelimiter: "/",
-			}),
-			"Sent Messages",
-		);
-	});
-
-	it("keeps the whole name when the server reports no delimiter", () => {
-		assert.equal(
-			mailboxLeafName({ fullPath: "Projects/Q3", hierarchyDelimiter: "" }),
-			"Projects/Q3",
-		);
-	});
-
-	it("keeps a top-level name that carries no delimiter", () => {
-		assert.equal(
-			mailboxLeafName({ fullPath: "INBOX", hierarchyDelimiter: "." }),
-			"INBOX",
-		);
-	});
-});

package/src/mailbox-name.ts

@@ -1,90 +0,0 @@
-export interface MailboxPath {
-	fullPath: string;
-	hierarchyDelimiter: string;
-}
-
-export interface MailboxNameCandidate extends MailboxPath {
-	mailboxId: string;
-}
-
-// A flat mailbox namespace reports no delimiter at all — ImapFlow gives `""`
-// for a NIL LIST delimiter — and splitting on "" returns single characters, so
-// the path is its own leaf.
-const segments = (mailbox: MailboxPath): string[] =>
-	mailbox.hierarchyDelimiter.length === 0
-		? [mailbox.fullPath]
-		: mailbox.fullPath.split(mailbox.hierarchyDelimiter);
-
-/**
- * The folder's own name: the last segment of its path under the delimiter its
- * own server reports (`INBOX/Spam` → `Spam`, `INBOX.Projects.Q3` → `Q3`).
- */
-export const mailboxLeafName = (mailbox: MailboxPath): string => {
-	const parts = segments(mailbox);
-	return parts[parts.length - 1] || mailbox.fullPath;
-};
-
-/**
- * Where a path under a renamed folder lands, or `undefined` when the rename did
- * not move it. IMAP RENAME moves the whole subtree in one command, so a path
- * inside the renamed branch moves exactly as far as its prefix does, and a path
- * merely starting with the same characters (`Workshop` beside `Work`) does not
- * move at all.
- *
- * Sliced rather than replaced. `String.prototype.replace` with a string pattern
- * expands `$&`, `` $` ``, `$'` and `$$` in the replacement, so a rename to a
- * folder whose name contains one of those wrote a different path locally from
- * the one the RENAME carried to the server — the row and the server diverge and
- * the next sweep inserts a second row for the real path.
- */
-export const rebaseMailboxPath = (
-	recorded: string,
-	oldPath: string,
-	newPath: string,
-	delimiter: string,
-): string | undefined => {
-	if (recorded === oldPath) return newPath;
-	if (delimiter.length === 0) return undefined;
-	if (!recorded.startsWith(`${oldPath}${delimiter}`)) return undefined;
-	return `${newPath}${recorded.slice(oldPath.length)}`;
-};
-
-const rank = (
-	mailbox: MailboxNameCandidate,
-	names: readonly string[],
-): number | null => {
-	const parts = segments(mailbox);
-	const nameIndex = names.indexOf(mailboxLeafName(mailbox).toLowerCase());
-	if (nameIndex < 0) return null;
-	// Depth outranks the name: a "Spam" buried under Trash or an archive must
-	// never beat the account's real "Junk" one level up.
-	return parts.length * names.length + nameIndex;
-};
-
-/**
- * A special-use folder by conventional name, for servers that advertise no
- * special-use flag for it. Matches the folder's own leaf segment against its
- * mailbox's own hierarchy delimiter, so it resolves at any depth under any
- * prefix (`INBOX/Spam`, `Mail.Junk E-mail`, `[Gmail]/Spam`) without knowing
- * which prefixes a server uses. `names` is ordered best-first and must be
- * lower case.
- */
-export const resolveMailboxByLeafName = <T extends MailboxNameCandidate>(
-	mailboxes: readonly T[],
-	names: readonly string[],
-): T | null => {
-	let best: { mailbox: T; rank: number } | null = null;
-	for (const mailbox of mailboxes) {
-		const candidate = rank(mailbox, names);
-		if (candidate === null) continue;
-		if (
-			!best ||
-			candidate < best.rank ||
-			(candidate === best.rank &&
-				mailbox.fullPath.localeCompare(best.mailbox.fullPath) < 0)
-		) {
-			best = { mailbox, rank: candidate };
-		}
-	}
-	return best?.mailbox ?? null;
-};

package/src/mailbox-state-doors.test.ts

@@ -1,104 +0,0 @@
-/**
- * The doors onto a folder's mutation state, proved by the compiler.
- *
- * `docs/architecture/folder-rename-and-delete.md` D3 says every transition of a
- * folder's state is a conditional write. A rule like that is worth exactly as
- * much as the thing enforcing it, and a convention enforces nothing: every
- * writer in the tree before this reached for the general-purpose `update()`,
- * because nothing stopped them.
- *
- * So `syncStatus` and `pendingPath` are gone from `UpdateMailboxInput`, and
- * `pendingPath` from `CreateMailboxInput` too — a create records no rename
- * target (T1). What is left is `transition` and `transitionSubtree`, both of
- * which take a predicate. Every `@ts-expect-error` below is a door that is
- * shut: put the field back and these stop erroring, which fails the build.
- *
- * `@ts-expect-error` is the assertion here, so this file is checked rather than
- * run. The one runtime case exists to keep the suite honest about having loaded
- * it.
- */
-
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import type {
-	CreateMailboxInput,
-	MailboxStatePredicate,
-	MailboxSubtreeTransitionIntent,
-	MailboxTransitionIntent,
-	UpdateMailboxInput,
-} from "./types.js";
-
-// --- The general-purpose writer refuses both state fields -------------------
-
-// @ts-expect-error `syncStatus` is mutation state: write it through a transition
-const syncStatus: UpdateMailboxInput = { syncStatus: "pending" };
-
-// @ts-expect-error `pendingPath` is mutation state
-const pendingPath: UpdateMailboxInput = { pendingPath: "Archive/2025" };
-
-// The insert records a state — the intent recorders say which — but never a
-// rename target, because a create has none.
-const created: CreateMailboxInput = {
-	accountId: "acct-1",
-	namespacePrefix: "",
-	hierarchyDelimiter: "/",
-	fullPath: "Archive",
-	uidValidity: 1,
-	uidNext: 1,
-	highestModseq: "0",
-	messageCount: 0,
-	unseenCount: 0,
-	deletedCount: 0,
-	totalSize: 0,
-	lastSyncUid: 0,
-	highWaterMarkUid: 0,
-	lastMessageSyncAt: 0,
-	syncStatus: "pending",
-};
-
-// @ts-expect-error a create records no rename target (T1)
-const createdWithTarget: CreateMailboxInput = { ...created, pendingPath: "X" };
-
-// Everything else about a folder still goes through `update()`, unchanged.
-const ordinary: UpdateMailboxInput = {
-	fullPath: "Archive/2025",
-	messageCount: 12,
-	cursorState: "cursor_invalid",
-};
-
-// --- The transitions are the doors, and they take a predicate ---------------
-
-const transition: MailboxTransitionIntent = {
-	from: ["pending"],
-	wherePendingPath: null,
-	to: "synced",
-	set: { fullPath: "INBOX/Archive", pendingPath: null },
-};
-
-const subtree: MailboxSubtreeTransitionIntent = {
-	from: ["synced", "failed"],
-	to: "pending",
-	rowSet: (row) => ({ pendingPath: row.fullPath }),
-};
-
-// The predicate names states, never a free-form column: a caller cannot smuggle
-// an unrelated field into the WHERE clause and call it a lock.
-const notAState: MailboxStatePredicate = {
-	from: ["synced"],
-	// @ts-expect-error `fullPath` is not part of a folder's mutation state
-	fullPath: "INBOX",
-};
-
-test("the folder-state doors are the two transitions", () => {
-	assert.equal(transition.to, "synced");
-	assert.equal(
-		subtree.rowSet({ fullPath: "Work" } as never).pendingPath,
-		"Work",
-	);
-	assert.equal(ordinary.messageCount, 12);
-	assert.deepEqual(
-		[syncStatus, pendingPath, createdWithTarget, notAState].length,
-		4,
-		"each field taken off an input, and the predicate's own shape, is pinned above",
-	);
-});

package/src/message-placement-doors.test.ts

@@ -1,100 +0,0 @@
-/**
- * The two doors, proved by the compiler.
- *
- * `docs/architecture/imap-mutations.md` R3 says a placement is written only as
- * a conditional write. A rule like that is worth exactly as much as the thing
- * enforcing it, and a convention enforces nothing: the first four writers on
- * this branch each reached for the general-purpose `update()` and nobody
- * noticed, because nothing stopped them.
- *
- * So the placement fields are gone from every input type but the two that are
- * allowed to carry them — `transitionPlacement`, which takes a predicate, and
- * the settle in `updateUid`, which takes no input object at all and writes what
- * the mail server confirmed. Every `@ts-expect-error` below is a door that is
- * shut: delete the omission from `UpdateMessageInput` and these stop erroring,
- * which fails the build.
- *
- * `@ts-expect-error` is the assertion here, so this file is checked rather than
- * run. The one runtime case exists to keep the suite honest about having loaded
- * it.
- */
-
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import type {
-	PlacementPredicate,
-	PlacementTransitionInput,
-	UpdateMessageInput,
-} from "./types.js";
-
-// --- The general-purpose writer refuses every placement field ---------------
-
-// @ts-expect-error `status` is a placement field: write it through a transition
-const status: UpdateMessageInput = { status: "moving" };
-
-// @ts-expect-error `syncStatus` is a placement field
-const syncStatus: UpdateMessageInput = { syncStatus: "failed" };
-
-// @ts-expect-error `abandonedMutation` is a placement field
-const abandonedMutation: UpdateMessageInput = { abandonedMutation: "delete" };
-
-// @ts-expect-error `mailboxId` is a placement field
-const mailboxId: UpdateMessageInput = { mailboxId: "mbx-1" };
-
-// @ts-expect-error `uid` is a placement field
-const uid: UpdateMessageInput = { uid: 42 };
-
-// @ts-expect-error `originalMailboxId` is a placement field
-const originalMailboxId: UpdateMessageInput = { originalMailboxId: "mbx-1" };
-
-// @ts-expect-error `originalUid` is a placement field
-const originalUid: UpdateMessageInput = { originalUid: 42 };
-
-// Everything else about a message still goes through it, unchanged.
-const ordinary: UpdateMessageInput = {
-	bodyStorageKey: "s3://body",
-	category: "personal",
-	spamReport: { reportedAt: 0 },
-};
-
-// --- The transition is the door, and it takes a predicate -------------------
-
-const transition: {
-	expected: PlacementPredicate;
-	next: PlacementTransitionInput;
-} = {
-	expected: { status: ["moving", "deleting"], mailboxId: "mbx-1", uid: 42 },
-	next: {
-		status: "active",
-		syncStatus: "abandoned",
-		abandonedMutation: "delete",
-		mailboxId: "mbx-1",
-		uid: 42,
-		originalMailboxId: null,
-		originalUid: null,
-	},
-};
-
-// The predicate names states, never a free-form column: a caller cannot smuggle
-// an unrelated field into the WHERE clause and call it a lock.
-// @ts-expect-error `category` is not part of a placement
-const notAPlacement: PlacementPredicate = { category: "personal" };
-
-test("the placement doors are the transition and the settle", () => {
-	assert.equal(transition.next.status, "active");
-	assert.equal(ordinary.category, "personal");
-	assert.deepEqual(
-		[
-			status,
-			syncStatus,
-			abandonedMutation,
-			mailboxId,
-			uid,
-			originalMailboxId,
-			originalUid,
-			notAPlacement,
-		].length,
-		8,
-		"each of the seven fields, and the predicate's own shape, is pinned above",
-	);
-});