@remit/mailbox-service 0.0.112 → 0.0.113

package/{src/placement-settled.ts → dist/placement-settled.d.ts}

@@ -1,6 +1,4 @@
 import type { MessageItem } from "@remit/data-ports";
-import { MessageStatus } from "@remit/domain-enums";
-
 /**
  * Whether the message row's placement is still an unconfirmed local write
  * (issue #496). While a move is in flight the row carries the destination in
@@ -21,12 +19,7 @@ import { MessageStatus } from "@remit/domain-enums";
  * same mismatched pair. Reading `moving` alone let a move enqueued behind a
  * delete bind to the row mid-delete and be dropped when the delete settled.
  */
-export const isPlacementUnsettled = (
-	message: Pick<MessageItem, "status">,
-): boolean =>
-	message.status === MessageStatus.moving ||
-	message.status === MessageStatus.deleting;
-
+export declare const isPlacementUnsettled: (message: Pick<MessageItem, "status">) => boolean;
 /**
  * Whether the row's `uid` belongs to a folder other than the one `mailboxId`
  * names — the state that makes the pair a lie rather than merely incomplete.
@@ -46,44 +39,17 @@ export const isPlacementUnsettled = (
  * untouched, so anything that resolves a uid off a row it did not settle
  * itself asks this rather than the binding below (issue #1217).
  */
-export const carriesForeignUid = <
-	T extends Pick<
-		MessageItem,
-		"mailboxId" | "uid" | "originalMailboxId" | "originalUid"
-	>,
->(
-	message: T,
-): message is T & { originalMailboxId: string; originalUid: number } =>
-	message.originalUid !== undefined &&
-	message.originalUid === message.uid &&
-	message.originalMailboxId !== undefined &&
-	message.originalMailboxId !== message.mailboxId;
-
+export declare const carriesForeignUid: <T extends Pick<MessageItem, "mailboxId" | "uid" | "originalMailboxId" | "originalUid">>(message: T) => message is T & {
+    originalMailboxId: string;
+    originalUid: number;
+};
 /**
  * The folder the row's `uid` is a uid in: the source while a move has not
  * confirmed, otherwise the folder the row is in. A fetch by uid is only safe
  * from this folder; from any other the same number names a different message.
  */
-export const uidMailboxIdOf = (
-	message: Pick<
-		MessageItem,
-		"mailboxId" | "uid" | "originalMailboxId" | "originalUid"
-	>,
-): string =>
-	carriesForeignUid(message) ? message.originalMailboxId : message.mailboxId;
-
-export const bindsForeignUid = (
-	message: Pick<
-		MessageItem,
-		"status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid"
-	>,
-): boolean => isPlacementUnsettled(message) && carriesForeignUid(message);
-
-/** A copy at `uid: 0`, which names nothing on the server until COPYUID lands (#1387). */
-const awaitsCopiedUid = (
-	message: Pick<MessageItem, "status" | "uid">,
-): boolean => message.status === MessageStatus.moving && message.uid === 0;
-
+export declare const uidMailboxIdOf: (message: Pick<MessageItem, "mailboxId" | "uid" | "originalMailboxId" | "originalUid">) => string;
+export declare const bindsForeignUid: (message: Pick<MessageItem, "status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid">) => boolean;
 /**
  * `in_flight` — a mutation is still working on the row, so waiting resolves it.
  * That includes a row mid-retry: `message-move`, `message-delete` and
@@ -100,22 +66,11 @@ const awaitsCopiedUid = (
  * IMAP rather than leaving a mismatched pair behind (#1005).
  */
 export type PlacementBinding = "consistent" | "in_flight";
-
-export const placementBindingOf = (
-	message: Pick<
-		MessageItem,
-		"status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid"
-	>,
-): PlacementBinding =>
-	bindsForeignUid(message) || awaitsCopiedUid(message)
-		? "in_flight"
-		: "consistent";
-
+export declare const placementBindingOf: (message: Pick<MessageItem, "status" | "mailboxId" | "uid" | "originalMailboxId" | "originalUid">) => PlacementBinding;
 export interface PlacementSettleOptions {
-	timeoutMs: number;
-	pollMs: number;
+    timeoutMs: number;
+    pollMs: number;
 }
-
 /**
  * Block a dependent mutation until the row's placement settles, then hand back
  * the confirmed row — the wait half of docs/architecture/imap-mutations.md R2.
@@ -124,16 +79,6 @@ export interface PlacementSettleOptions {
  * when the deadline passes; the caller decides what a dependency that never
  * settled means for it.
  */
-export const waitForPlacementToSettle = async (
-	messageService: { get(messageId: string): Promise<MessageItem> },
-	messageId: string,
-	{ timeoutMs, pollMs }: PlacementSettleOptions,
-): Promise<MessageItem> => {
-	const deadline = Date.now() + timeoutMs;
-	let message = await messageService.get(messageId);
-	while (isPlacementUnsettled(message) && Date.now() < deadline) {
-		await new Promise((resolve) => setTimeout(resolve, pollMs));
-		message = await messageService.get(messageId);
-	}
-	return message;
-};
+export declare const waitForPlacementToSettle: (messageService: {
+    get(messageId: string): Promise<MessageItem>;
+}, messageId: string, { timeoutMs, pollMs }: PlacementSettleOptions) => Promise<MessageItem>;

package/dist/placement-settled.js

@@ -0,0 +1,75 @@
+import { MessageStatus } from "@remit/domain-enums";
+/**
+ * Whether the message row's placement is still an unconfirmed local write
+ * (issue #496). While a move is in flight the row carries the destination in
+ * `mailboxId` but the SOURCE folder's `uid` — the pair is only made consistent
+ * when the IMAP move confirms and `updateUid` writes the destination's COPYUID.
+ * Any dependent mutation that resolves a folder and a uid from such a row
+ * therefore addresses the destination's OWN message at that uid: a different
+ * message, on a mailbox Remit is never the only client of.
+ *
+ * `syncStatus` is not the signal. An ordinary freshly-synced inbound row is
+ * `pending` forever (nothing on the inbound path promotes it), so keying off it
+ * defers every outbound mutation in the product. `status` is what an actual
+ * mutation writes and what settling clears.
+ *
+ * Both in-flight states count, per the R3 state table: a delete points the row
+ * at Trash with the source's uid exactly as a move points it at the
+ * destination, so a dependent mutation that reads a `deleting` row resolves the
+ * same mismatched pair. Reading `moving` alone let a move enqueued behind a
+ * delete bind to the row mid-delete and be dropped when the delete settled.
+ */
+export const isPlacementUnsettled = (message) => message.status === MessageStatus.moving ||
+    message.status === MessageStatus.deleting;
+/**
+ * Whether the row's `uid` belongs to a folder other than the one `mailboxId`
+ * names — the state that makes the pair a lie rather than merely incomplete.
+ *
+ * The optimistic half of a move is the only writer of this shape: it points the row at the
+ * destination and records the pre-move pair, leaving `uid` untouched until the
+ * server confirms and `updateUid` replaces it. A row with no `originalUid` was
+ * never moved, so its uid names nothing but itself — a freshly copied row is
+ * `moving` with `uid: 0` until COPYUID lands, which is a uid that is not ready,
+ * not a uid that names somebody else's message.
+ *
+ * Answered without reference to `status`, because `status` is not what clears
+ * it: `updateUid` does, dropping `originalUid` in the same statement that
+ * writes the destination's own, and a restore does by pointing `mailboxId`
+ * back at `originalMailboxId`. An operation that rewrites `status` on its way
+ * past — Empty Trash marking a whole folder `deleting` — leaves the pair
+ * untouched, so anything that resolves a uid off a row it did not settle
+ * itself asks this rather than the binding below (issue #1217).
+ */
+export const carriesForeignUid = (message) => message.originalUid !== undefined &&
+    message.originalUid === message.uid &&
+    message.originalMailboxId !== undefined &&
+    message.originalMailboxId !== message.mailboxId;
+/**
+ * The folder the row's `uid` is a uid in: the source while a move has not
+ * confirmed, otherwise the folder the row is in. A fetch by uid is only safe
+ * from this folder; from any other the same number names a different message.
+ */
+export const uidMailboxIdOf = (message) => carriesForeignUid(message) ? message.originalMailboxId : message.mailboxId;
+export const bindsForeignUid = (message) => isPlacementUnsettled(message) && carriesForeignUid(message);
+/** A copy at `uid: 0`, which names nothing on the server until COPYUID lands (#1387). */
+const awaitsCopiedUid = (message) => message.status === MessageStatus.moving && message.uid === 0;
+export const placementBindingOf = (message) => bindsForeignUid(message) || awaitsCopiedUid(message)
+    ? "in_flight"
+    : "consistent";
+/**
+ * Block a dependent mutation until the row's placement settles, then hand back
+ * the confirmed row — the wait half of docs/architecture/imap-mutations.md R2.
+ * A move ordinarily settles in well under a second, so blocking is the cheap
+ * option the doc's default guidance names. The row comes back still unsettled
+ * when the deadline passes; the caller decides what a dependency that never
+ * settled means for it.
+ */
+export const waitForPlacementToSettle = async (messageService, messageId, { timeoutMs, pollMs }) => {
+    const deadline = Date.now() + timeoutMs;
+    let message = await messageService.get(messageId);
+    while (isPlacementUnsettled(message) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        message = await messageService.get(messageId);
+    }
+    return message;
+};

package/dist/quarantine.d.ts

@@ -0,0 +1,95 @@
+import type { IMailboxSpecialUseRepository, IQuarantineRepository, MessageData, MessageItem, QuarantineItem, QuarantineMimeNodeItem } from "@remit/data-ports";
+type CanonicalRole = NonNullable<QuarantineItem["mailboxRole"]>;
+type FailureStage = QuarantineItem["failureStage"];
+type FailureCode = QuarantineItem["failureCode"];
+/**
+ * The canonical role of the folder a quarantined message arrived in, read from
+ * the server's own RFC 6154 SPECIAL-USE declaration — the same source the
+ * appointment flow seeds from. A folder the server declares nothing about has
+ * no role, which is the normal state for a plain folder and is why the field
+ * is optional. `Important` is a SPECIAL-USE with no canonical role and drops
+ * out here rather than being invented into one.
+ */
+export declare const resolveMailboxRole: (mailboxPath: string, specialUse: readonly string[]) => CanonicalRole | undefined;
+/** Everything about the quarantine that is the same for every uid in a round. */
+export interface QuarantineContext {
+    accountId: string;
+    accountConfigId: string;
+    mailboxId: string;
+    mailboxPath: string;
+    uidValidity: number;
+    /** Rounds tried before the message was set aside. */
+    attempts: number;
+}
+/**
+ * The repro fingerprint: what the message declared itself to be. Every field
+ * is optional-by-absence because a message can fail before its shape was read,
+ * and a required column would force the writer to invent a value or drop the
+ * record.
+ */
+export interface QuarantineMessageShape {
+    contentType?: string;
+    transferEncoding?: string;
+    charset?: string;
+    sizeBytes?: number;
+    structure: QuarantineMimeNodeItem[];
+    messageIdHash?: string;
+}
+export interface QuarantineFailure {
+    stage: FailureStage;
+    code: FailureCode;
+    /** Parser error text. Stored, shown on screen, never published. */
+    message: string;
+    partPath?: string;
+}
+/**
+ * Message shape off the rows metadata sync already wrote. The body path has no
+ * FETCH result to read — it streams raw bytes — but the MIME tree it needs was
+ * walked into BodyPart rows when the message's metadata was synced, so the
+ * fingerprint comes from there rather than from re-reading headers the parser
+ * has just refused.
+ */
+export declare const shapeFromMessageData: (message: Pick<MessageItem, "rfc822Size">, data: MessageData, messageIdHeader: string | undefined) => QuarantineMessageShape;
+/**
+ * The set of messages already set aside, held for the duration of one sync
+ * round. A round loads it once and filters against it in memory: the list is
+ * small by design — a growing one is a bug being reported, not a page to
+ * paginate — and a lookup per message would put a query on the hot path for a
+ * state that is almost always empty.
+ */
+export declare class QuarantinedUids {
+    private readonly keys;
+    constructor(entries: readonly QuarantineItem[]);
+    get size(): number;
+    has(mailboxId: string, uidValidity: number, uid: number): boolean;
+}
+export interface QuarantineLogger {
+    info(obj: Record<string, unknown>, msg: string): void;
+    warn(obj: Record<string, unknown>, msg: string): void;
+}
+/**
+ * Writes the record a message becomes when the sync path cannot apply it
+ * (issue #72), and loads the set a round filters against.
+ *
+ * Only a message defect reaches this class. Deciding that is the caller's job
+ * and it is made at exactly one kind of catch site — one narrow enough that
+ * the error can only have come from the message itself. An S3, queue or
+ * database failure propagates; writing one here would advance a cursor past
+ * mail that is fine and tell the user it was unreadable.
+ */
+export declare class QuarantineService {
+    private readonly repository;
+    private readonly mailboxSpecialUseService;
+    private readonly workerVersion;
+    private readonly log;
+    constructor(repository: IQuarantineRepository, mailboxSpecialUseService: IMailboxSpecialUseRepository, workerVersion: string, log: QuarantineLogger);
+    load(accountConfigId: string): Promise<QuarantinedUids>;
+    /**
+     * Set a message aside. Resolves only once the row is durable, because the
+     * caller's next act is to let a cursor move past this uid — and a cursor
+     * that moves past work no record survives is the silent loss this whole
+     * feature exists to end.
+     */
+    record(context: QuarantineContext, uid: number, failure: QuarantineFailure, shape?: QuarantineMessageShape): Promise<void>;
+}
+export {};

package/dist/quarantine.js

@@ -0,0 +1,131 @@
+import { quarantineMessageIdHash, ROOT_PART_PATH } from "@remit/data-ports/id";
+import { CanonicalMailboxRole } from "@remit/domain-enums";
+const CANONICAL_ROLES = new Set(Object.values(CanonicalMailboxRole));
+/**
+ * The canonical role of the folder a quarantined message arrived in, read from
+ * the server's own RFC 6154 SPECIAL-USE declaration — the same source the
+ * appointment flow seeds from. A folder the server declares nothing about has
+ * no role, which is the normal state for a plain folder and is why the field
+ * is optional. `Important` is a SPECIAL-USE with no canonical role and drops
+ * out here rather than being invented into one.
+ */
+export const resolveMailboxRole = (mailboxPath, specialUse) => {
+    if (mailboxPath.toUpperCase() === "INBOX")
+        return CanonicalMailboxRole.Inbox;
+    const matched = specialUse.find((use) => CANONICAL_ROLES.has(use));
+    return matched;
+};
+const EMPTY_SHAPE = { structure: [] };
+/**
+ * Message shape off the rows metadata sync already wrote. The body path has no
+ * FETCH result to read — it streams raw bytes — but the MIME tree it needs was
+ * walked into BodyPart rows when the message's metadata was synced, so the
+ * fingerprint comes from there rather than from re-reading headers the parser
+ * has just refused.
+ */
+export const shapeFromMessageData = (message, data, messageIdHeader) => {
+    const parts = [...data.bodyPart].sort((a, b) => a.partPath.localeCompare(b.partPath, "en", { numeric: true }));
+    const root = parts.find((part) => part.partPath === ROOT_PART_PATH);
+    const rootCharset = root
+        ? data.bodyPartParameter.find((param) => param.bodyPartId === root.bodyPartId &&
+            param.parameterName.toLowerCase() === "charset")?.parameterValue
+        : undefined;
+    return {
+        ...(root ? { contentType: `${root.mediaType}/${root.mediaSubtype}` } : {}),
+        ...(root ? { transferEncoding: root.transferEncoding } : {}),
+        ...(rootCharset ? { charset: rootCharset } : {}),
+        ...(message.rfc822Size ? { sizeBytes: message.rfc822Size } : {}),
+        structure: parts.map((part) => ({
+            depth: partPathDepth(part.partPath),
+            contentType: `${part.mediaType}/${part.mediaSubtype}`,
+        })),
+        ...hashOf(messageIdHeader),
+    };
+};
+const partPathDepth = (partPath) => partPath === ROOT_PART_PATH ? 0 : partPath.split(".").length;
+const hashOf = (messageIdHeader) => {
+    const messageIdHash = quarantineMessageIdHash(messageIdHeader);
+    return messageIdHash ? { messageIdHash } : {};
+};
+/**
+ * The set of messages already set aside, held for the duration of one sync
+ * round. A round loads it once and filters against it in memory: the list is
+ * small by design — a growing one is a bug being reported, not a page to
+ * paginate — and a lookup per message would put a query on the hot path for a
+ * state that is almost always empty.
+ */
+export class QuarantinedUids {
+    keys;
+    constructor(entries) {
+        this.keys = new Set(entries.map((entry) => uidKey(entry.mailboxId, entry.uidValidity, entry.uid)));
+    }
+    get size() {
+        return this.keys.size;
+    }
+    has(mailboxId, uidValidity, uid) {
+        return this.keys.has(uidKey(mailboxId, uidValidity, uid));
+    }
+}
+const uidKey = (mailboxId, uidValidity, uid) => `${mailboxId}:${uidValidity}:${uid}`;
+/**
+ * Writes the record a message becomes when the sync path cannot apply it
+ * (issue #72), and loads the set a round filters against.
+ *
+ * Only a message defect reaches this class. Deciding that is the caller's job
+ * and it is made at exactly one kind of catch site — one narrow enough that
+ * the error can only have come from the message itself. An S3, queue or
+ * database failure propagates; writing one here would advance a cursor past
+ * mail that is fine and tell the user it was unreadable.
+ */
+export class QuarantineService {
+    repository;
+    mailboxSpecialUseService;
+    workerVersion;
+    log;
+    constructor(repository, mailboxSpecialUseService, workerVersion, log) {
+        this.repository = repository;
+        this.mailboxSpecialUseService = mailboxSpecialUseService;
+        this.workerVersion = workerVersion;
+        this.log = log;
+    }
+    async load(accountConfigId) {
+        return new QuarantinedUids(await this.repository.listByAccountConfigId(accountConfigId));
+    }
+    /**
+     * Set a message aside. Resolves only once the row is durable, because the
+     * caller's next act is to let a cursor move past this uid — and a cursor
+     * that moves past work no record survives is the silent loss this whole
+     * feature exists to end.
+     */
+    async record(context, uid, failure, shape = EMPTY_SHAPE) {
+        // Resolved here rather than per round: a round almost never writes a row,
+        // so the lookup belongs on the write and not on the hot path.
+        const specialUse = await this.mailboxSpecialUseService.listByMailboxId(context.mailboxId);
+        const mailboxRole = resolveMailboxRole(context.mailboxPath, specialUse.map((entry) => entry.specialUse));
+        await this.repository.upsert({
+            accountConfigId: context.accountConfigId,
+            accountId: context.accountId,
+            mailboxId: context.mailboxId,
+            uidValidity: context.uidValidity,
+            uid,
+            ...(mailboxRole ? { mailboxRole } : {}),
+            mailboxPath: context.mailboxPath,
+            quarantinedAt: Date.now(),
+            attempts: context.attempts,
+            failureStage: failure.stage,
+            failureCode: failure.code,
+            failureMessage: failure.message,
+            ...(failure.partPath ? { failurePartPath: failure.partPath } : {}),
+            workerVersion: this.workerVersion,
+            ...shape,
+        });
+        this.log.warn({
+            mailboxId: context.mailboxId,
+            mailboxPath: context.mailboxPath,
+            uid,
+            uidValidity: context.uidValidity,
+            failureStage: failure.stage,
+            failureCode: failure.code,
+        }, "Message quarantined; cursor may advance past it");
+    }
+}

package/dist/refusal.d.ts

@@ -0,0 +1,31 @@
+import type { MailboxItem } from "@remit/data-ports";
+export type AccessMode = "read" | "act";
+export type Refusal = {
+    kind: "Invalid";
+    message: string;
+} | {
+    kind: "Forbidden";
+    message: string;
+} | {
+    kind: "NotFound";
+    message: string;
+} | {
+    kind: "Conflict";
+    message: string;
+} | {
+    kind: "NotSettled";
+    message: string;
+    mailboxId: string;
+    syncStatus: MailboxItem["syncStatus"];
+};
+export interface Refused {
+    ok: false;
+    refusal: Refusal;
+}
+export type Refusable<T> = {
+    ok: true;
+    value: T;
+} | Refused;
+export declare const accept: <T>(value: T) => Refusable<T>;
+export declare const refuse: (refusal: Refusal) => Refused;
+export declare const invalid: (message: string) => Refused;

package/dist/refusal.js

@@ -0,0 +1,3 @@
+export const accept = (value) => ({ ok: true, value });
+export const refuse = (refusal) => ({ ok: false, refusal });
+export const invalid = (message) => refuse({ kind: "Invalid", message });

package/{src/restore-source-placement.ts → dist/restore-source-placement.d.ts}

@@ -1,52 +1,37 @@
-import type {
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import { isNotFoundError } from "@remit/data-ports/errors";
-import { MessageStatus } from "@remit/domain-enums";
-import { buildThreadMessageMoveRevert } from "./thread-message-rows.js";
-
+import type { IMessageRepository, IThreadMessageRepository, MessageItem, ThreadMessageItem } from "@remit/data-ports";
 export interface RestoreSourcePlacementDeps {
-	messageService: Pick<IMessageRepository, "transitionPlacement">;
-	threadMessageService: Pick<
-		IThreadMessageRepository,
-		"findAllByMessageId" | "update"
-	>;
+    messageService: Pick<IMessageRepository, "transitionPlacement">;
+    threadMessageService: Pick<IThreadMessageRepository, "findAllByMessageId" | "update">;
 }
-
 /** Whether the row was still owed a restore when this ran. */
 export type RestoreSourcePlacementOutcome = "restored" | "superseded";
-
 export interface RestoreSourcePlacementInput {
-	accountConfigId: string;
-	messageId: string;
-	sourceMailboxId: string;
-	uid: number;
-	/**
-	 * What the row records about the mutation that will now never happen.
-	 * `synced` where the row is a faithful projection of the source again and
-	 * nothing was refused. `abandoned` where a mutation the user asked for gave
-	 * up, which is a failure the row has to carry (imap-mutations R3).
-	 */
-	syncStatus: MessageItem["syncStatus"];
-	/**
-	 * Which mutation gave up, for the row to carry alongside `abandoned`. The
-	 * hand-back is about to set `status` back to `active`, and `status` was the
-	 * only field naming it — without this the client can see that something was
-	 * abandoned and not what, which is how a move that handed back was reported
-	 * as a failed delete (issue #1229). `none` accompanies every other
-	 * `syncStatus`, so the field never outlives its gate.
-	 */
-	abandonedMutation: MessageItem["abandonedMutation"];
-	/**
-	 * The listing rows, where the caller has already read them to pick this
-	 * outcome. Omitted, they are read here.
-	 */
-	threadMessages?: ThreadMessageItem[];
+    accountConfigId: string;
+    messageId: string;
+    sourceMailboxId: string;
+    uid: number;
+    /**
+     * What the row records about the mutation that will now never happen.
+     * `synced` where the row is a faithful projection of the source again and
+     * nothing was refused. `abandoned` where a mutation the user asked for gave
+     * up, which is a failure the row has to carry (imap-mutations R3).
+     */
+    syncStatus: MessageItem["syncStatus"];
+    /**
+     * Which mutation gave up, for the row to carry alongside `abandoned`. The
+     * hand-back is about to set `status` back to `active`, and `status` was the
+     * only field naming it — without this the client can see that something was
+     * abandoned and not what, which is how a move that handed back was reported
+     * as a failed delete (issue #1229). `none` accompanies every other
+     * `syncStatus`, so the field never outlives its gate.
+     */
+    abandonedMutation: MessageItem["abandonedMutation"];
+    /**
+     * The listing rows, where the caller has already read them to pick this
+     * outcome. Omitted, they are read here.
+     */
+    threadMessages?: ThreadMessageItem[];
 }
-
 /**
  * Put a row back on the pre-mutation source pair and hand its listing rows back
  * with it.
@@ -97,57 +82,4 @@ export interface RestoreSourcePlacementInput {
  * `.catch()` and cost the record its ack and its resync, which is the contract
  * the terminal resolvers state: never re-thrown.
  */
-export const restoreSourcePlacement = async (
-	deps: RestoreSourcePlacementDeps,
-	input: RestoreSourcePlacementInput,
-): Promise<RestoreSourcePlacementOutcome> => {
-	const {
-		accountConfigId,
-		messageId,
-		sourceMailboxId,
-		uid,
-		syncStatus,
-		abandonedMutation,
-	} = input;
-
-	const skipNotFound = (error: unknown): void => {
-		if (isNotFoundError(error)) return;
-		throw error;
-	};
-
-	const restored = await deps.messageService.transitionPlacement(
-		messageId,
-		{ status: [MessageStatus.moving, MessageStatus.deleting] },
-		{
-			mailboxId: sourceMailboxId,
-			uid,
-			status: MessageStatus.active,
-			syncStatus,
-			abandonedMutation,
-		},
-	);
-	if (!restored) return "superseded";
-
-	const threadMessages =
-		input.threadMessages ??
-		(await deps.threadMessageService.findAllByMessageId(
-			accountConfigId,
-			messageId,
-		));
-	for (const threadMessage of threadMessages) {
-		const args = buildThreadMessageMoveRevert(
-			threadMessage,
-			uid,
-			sourceMailboxId,
-		);
-		await deps.threadMessageService
-			.update(
-				threadMessage.accountConfigId,
-				threadMessage.threadMessageId,
-				args.set,
-				{ composites: args.composites },
-			)
-			.catch(skipNotFound);
-	}
-	return "restored";
-};
+export declare const restoreSourcePlacement: (deps: RestoreSourcePlacementDeps, input: RestoreSourcePlacementInput) => Promise<RestoreSourcePlacementOutcome>;