@remit/web-client 0.0.325 → 0.0.326

package/dist/src/routing/fragment.js

@@ -0,0 +1,112 @@
+import { useLocation, useNavigate } from "@tanstack/react-router";
+import { useCallback, useMemo } from "react";
+import { z } from "zod";
+import { useIsDesktop } from "../hooks/useMediaQuery";
+/**
+ * The fragment tier carries panel visibility and nothing else — no identity, no
+ * payload, no selection. A panel qualifies only when its own copy is
+ * independent of in-memory data, so a cold load of the URL reproduces it
+ * exactly.
+ */
+export const panelFragments = ["intelligence", "nav", "shortcuts"];
+/**
+ * The panels that cover the view rather than sit in it. The rail is a pane in
+ * the shell's row and the other two are modal over it, so a sheet opening can
+ * never take the rail down with it — the address holds the pane and the overlay
+ * at once. Two overlays cannot be up together, because the second one hides the
+ * first.
+ */
+export const overlayPanels = ["nav", "shortcuts"];
+export const isOverlayPanel = (panel) => overlayPanels.includes(panel);
+/**
+ * The set an overlay opening or closing leaves behind it.
+ *
+ * A write states the whole set, so raising the nav slide-over has to say what
+ * else is up or it takes it down. The panes stay and the previous overlay goes,
+ * because two overlays cannot both be up — which is how a reader crossing from
+ * their mail into the calendar and reaching for the folders keeps the rail they
+ * arrived with.
+ */
+export function panelsWithOverlay(open, overlay) {
+    return [
+        ...open.filter((panel) => !isOverlayPanel(panel)),
+        ...(overlay ? [overlay] : []),
+    ];
+}
+const panelFragmentSchema = z.enum(panelFragments);
+/**
+ * The panels the address asks for, in the union's own order so one set of open
+ * panels has one spelling. A hand-edited or stale URL is a normal thing to
+ * receive, so an unrecognised name is dropped instead of throwing.
+ */
+export function parseOpenPanels(hash) {
+    const named = new Set(hash
+        .split(",")
+        .map((token) => panelFragmentSchema.safeParse(token))
+        .filter((parsed) => parsed.success)
+        .map((parsed) => parsed.data));
+    return panelFragments.filter((panel) => named.has(panel));
+}
+/** The address a set of open panels is written as. */
+export function formatOpenPanels(panels) {
+    return panelFragments.filter((panel) => panels.includes(panel)).join(",");
+}
+/** The panels the address currently asks for. */
+export function useOpenPanels() {
+    const hash = useLocation({
+        select: (location) => formatOpenPanels(parseOpenPanels(location.hash)),
+    });
+    return useMemo(() => parseOpenPanels(hash), [hash]);
+}
+/**
+ * Whether a navigation carries this panel at this tier.
+ *
+ * A pane is chrome a reader keeps up while they move from one conversation to
+ * the next; an overlay is dismissed by going somewhere, which is what closing
+ * it means. Below desktop the rail is not a pane at all — it is a full-screen
+ * drawer over the open message — so it belongs to the thread it was opened for
+ * and a navigation leaves it behind, rather than covering a message nobody
+ * asked to cover (#777).
+ */
+const isRetainedPanel = (panel, isDesktop) => !isOverlayPanel(panel) && isDesktop;
+/**
+ * A destination's `hash`, for a navigation that keeps the reader where they
+ * are. The router drops the fragment on every navigation unless the destination
+ * asks for it, so this is what a link or a `navigate` call passes to state the
+ * rule rather than restate it.
+ *
+ * The tier is bound here rather than passed at the call site, so the updater
+ * still has the shape the router hands a previous fragment to. That parameter
+ * is optional because the router types it `string | undefined`.
+ */
+export function retainOpenPanelsAtTier(isDesktop) {
+    return (hash = "") => formatOpenPanels(parseOpenPanels(hash).filter((panel) => isRetainedPanel(panel, isDesktop)));
+}
+/**
+ * The `hash` updater for a navigation from the surface the reader is on. The
+ * layout tier is read here, once, so no call site decides for itself what a
+ * navigation keeps.
+ */
+export function useRetainOpenPanels() {
+    const isDesktop = useIsDesktop();
+    return useMemo(() => retainOpenPanelsAtTier(isDesktop), [isDesktop]);
+}
+/**
+ * Puts a set of panels up, replacing whatever was up before.
+ *
+ * `replace`, because a panel is chrome over the current view rather than a place
+ * to go: Back belongs to the message the reader came from, not to the rail they
+ * just collapsed. The fragment names panels and never an element, so it is not
+ * an anchor to scroll to either.
+ */
+export function useSetOpenPanels() {
+    const navigate = useNavigate();
+    return useCallback((panels) => {
+        navigate({
+            search: true,
+            hash: formatOpenPanels(panels),
+            replace: true,
+            hashScrollIntoView: false,
+        });
+    }, [navigate]);
+}

package/dist/src/routing/index.d.ts

@@ -0,0 +1,14 @@
+export { type BrowsedList, useBrowsedList, useOpensDetail, } from "./browsed-list";
+export { type CalendarAddress, type CalendarNavigation, type OpenCalendarEvent, useCalendarAddress, useCalendarNavigation, useChangeSuggestionOnCalendar, useChangingSuggestionId, useIsWritingEvent, useOpenCalendarEvent, useOpenEventOnCalendar, } from "./calendar";
+export { useAdoptComposeDraft, useCloseCompose, useComposeDraftId, useEditDraft, useIsComposing, useOpenCompose, } from "./compose";
+export { formatOpenPanels, isOverlayPanel, type OverlayPanel, overlayPanels, type PanelFragment, panelFragments, panelsWithOverlay, parseOpenPanels, retainOpenPanelsAtTier, useOpenPanels, useRetainOpenPanels, useSetOpenPanels, } from "./fragment";
+export { NavLink, type NavLinkProps } from "./nav-link";
+export { useSelectedNavId } from "./nav-selection";
+export { type OpenThreadOptions, type OpenThreadPath, type OpenThreadTarget, useCloseThread, useOpenThread, useOpenThreadPath, } from "./open-thread";
+export { useCloseOutboxDraft, useOpenOutboxDraft, useOutboxDraftId, } from "./outbox-draft";
+export { type ReplyAddress, type ReplyMode, type ReplySurface, type ReplyTarget, replyModes, replyToThread, useAdoptReplyDraft, useCloseReply, useIsReplying, useOpenReply, useReplySurface, } from "./reply";
+export { type SearchField, useSearchField } from "./search-field";
+export { type SearchMirrorTarget, useSearchMirror } from "./search-mirror";
+export { useScopeSearchToMailbox, useSearchEverything, } from "./search-navigation";
+export { type AppSection, useConfigureAccountSmtp, useGoToSection, } from "./sections";
+export { ownedHistoryEntries, type SelectionWizardControl, useOpenWizard, useSelectionWizard, useWizardEntryValue, useWizardStep, useWizardStepValue, type WizardEntry, type WizardStepNavigation, wizardEntryFromParam, wizardEntryValue, wizardStepFromParam, wizardStepValue, } from "./wizard-history";

package/dist/src/routing/index.js

@@ -0,0 +1,14 @@
+export { useBrowsedList, useOpensDetail, } from "./browsed-list";
+export { useCalendarAddress, useCalendarNavigation, useChangeSuggestionOnCalendar, useChangingSuggestionId, useIsWritingEvent, useOpenCalendarEvent, useOpenEventOnCalendar, } from "./calendar";
+export { useAdoptComposeDraft, useCloseCompose, useComposeDraftId, useEditDraft, useIsComposing, useOpenCompose, } from "./compose";
+export { formatOpenPanels, isOverlayPanel, overlayPanels, panelFragments, panelsWithOverlay, parseOpenPanels, retainOpenPanelsAtTier, useOpenPanels, useRetainOpenPanels, useSetOpenPanels, } from "./fragment";
+export { NavLink } from "./nav-link";
+export { useSelectedNavId } from "./nav-selection";
+export { useCloseThread, useOpenThread, useOpenThreadPath, } from "./open-thread";
+export { useCloseOutboxDraft, useOpenOutboxDraft, useOutboxDraftId, } from "./outbox-draft";
+export { replyModes, replyToThread, useAdoptReplyDraft, useCloseReply, useIsReplying, useOpenReply, useReplySurface, } from "./reply";
+export { useSearchField } from "./search-field";
+export { useSearchMirror } from "./search-mirror";
+export { useScopeSearchToMailbox, useSearchEverything, } from "./search-navigation";
+export { useConfigureAccountSmtp, useGoToSection, } from "./sections";
+export { ownedHistoryEntries, useOpenWizard, useSelectionWizard, useWizardEntryValue, useWizardStep, useWizardStepValue, wizardEntryFromParam, wizardEntryValue, wizardStepFromParam, wizardStepValue, } from "./wizard-history";

package/dist/src/routing/nav-link.d.ts

@@ -0,0 +1,28 @@
+import { NavLinkSurface } from "@remit/ui";
+import type { AnyRouter, LinkComponentProps, RegisteredRouter } from "@tanstack/react-router";
+import type { ReactElement } from "react";
+import { type PanelFragment } from "./fragment";
+/**
+ * The router's own link props, minus the raw `hash`: the fragment tier is a
+ * closed union of panel names, so `fragment` is the only way to write it.
+ */
+export type NavLinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ""> = LinkComponentProps<typeof NavLinkSurface, TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    fragment?: PanelFragment;
+    /**
+     * Closed off rather than omitted: `Omit` over these props is a mapped type,
+     * and the router's `to` / `params` / `search` inference cannot see through
+     * one.
+     */
+    hash?: never;
+};
+/**
+ * The application's only navigation link. `createLink` keeps the router's `to` /
+ * `params` / `search` inference, so a route that does not exist or a param set
+ * that does not match it fails to compile instead of rendering a blank pane.
+ *
+ * A link that names no panel carries the open panes across: the rail is up
+ * until the reader puts it down, and every row in a list is a link. Overlays
+ * are left behind, because going somewhere is what dismisses one — and below
+ * desktop so is the rail, which is a drawer over the message there.
+ */
+export declare function NavLink<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: NavLinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): ReactElement;

package/dist/src/routing/nav-link.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { NavLinkSurface } from "@remit/ui";
+import { createLink } from "@tanstack/react-router";
+import { useRetainOpenPanels } from "./fragment";
+const RouterNavLink = createLink(NavLinkSurface);
+export function NavLink({ fragment, ...props }) {
+    const retainPanels = useRetainOpenPanels();
+    return _jsx(RouterNavLink, { ...props, hash: fragment ?? retainPanels });
+}

package/dist/src/routing/nav-selection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The nav entry the address selects, or `""` where none does.
+ *
+ *   - `/settings/*` → "settings"
+ *   - `/calendar/*` → "calendar"
+ *   - `/mail/outbox`, `/mail/flagged`, `/mail/brief` → that list
+ *   - `/mail/$mailboxId` → the mailbox id, which is what the sidebar keys on
+ *
+ * Read off the pathname rather than the matches: the router commits the new
+ * location before it swaps them, so the entry the reader just tapped highlights
+ * on the tap instead of when its list finishes loading.
+ */
+export declare function useSelectedNavId(): string;

package/dist/src/routing/nav-selection.js

@@ -0,0 +1,29 @@
+import { useLocation, useParams } from "@tanstack/react-router";
+import { locationIsOnList } from "../lib/mail-route";
+/**
+ * The nav entry the address selects, or `""` where none does.
+ *
+ *   - `/settings/*` → "settings"
+ *   - `/calendar/*` → "calendar"
+ *   - `/mail/outbox`, `/mail/flagged`, `/mail/brief` → that list
+ *   - `/mail/$mailboxId` → the mailbox id, which is what the sidebar keys on
+ *
+ * Read off the pathname rather than the matches: the router commits the new
+ * location before it swaps them, so the entry the reader just tapped highlights
+ * on the tap instead of when its list finishes loading.
+ */
+export function useSelectedNavId() {
+    const { pathname } = useLocation();
+    const mailbox = useParams({ from: "/mail/$mailboxId", shouldThrow: false });
+    if (locationIsOnList(pathname, "/settings"))
+        return "settings";
+    if (locationIsOnList(pathname, "/calendar"))
+        return "calendar";
+    if (locationIsOnList(pathname, "/mail/outbox"))
+        return "outbox";
+    if (locationIsOnList(pathname, "/mail/flagged"))
+        return "flagged";
+    if (locationIsOnList(pathname, "/mail/brief"))
+        return "brief";
+    return mailbox?.mailboxId ?? "";
+}

package/dist/src/routing/open-thread.d.ts

@@ -0,0 +1,65 @@
+/** The conversation a list has open, as the address states it. */
+export interface OpenThreadPath {
+    threadId: string;
+    /**
+     * Which message inside the thread is expanded and scrolled to. Absent on a
+     * bare thread address, where the newest message answers for the conversation.
+     */
+    messageId: string | undefined;
+}
+/**
+ * A conversation to open. The thread is what the pane fetches by; the message is
+ * the row the reader pointed at, so a list always knows both.
+ */
+export interface OpenThreadTarget {
+    threadId: string;
+    messageId: string;
+}
+/**
+ * The thread the address has open, whichever list is browsing it.
+ *
+ * The thread is a child route of the list, and the list layout mounts the pane
+ * above the `Outlet` — so it asks the router which of its children matched
+ * rather than reading a param it does not own. A path matches one list at a
+ * time, so one hook answers for every list rather than each list keeping its
+ * own copy of the same question. Each `from` names a real route, so a segment
+ * that does not exist fails to compile.
+ */
+export declare function useOpenThreadPath(): OpenThreadPath | undefined;
+/** How an open differs from the plain one, where it does. */
+export interface OpenThreadOptions {
+    /** Replace the entry rather than push one, so Back skips the row. */
+    replace?: boolean;
+    /**
+     * Commit this query with the open. The debounced q-mirror walks back up to
+     * the list when a query goes active, so a row tapped before the debounce
+     * settles is closed again a moment later unless the address already says the
+     * query the conversation was opened under. Omitted, the open carries whatever
+     * query the address already had.
+     */
+    query?: string;
+    /**
+     * Open under this mailbox rather than the one being browsed. A search hit
+     * carries its own, so a row can never open under a mailbox it does not belong
+     * to.
+     */
+    mailboxId?: string;
+}
+/**
+ * Open a conversation on the list the reader is browsing.
+ *
+ * The thread is a child route of its list, so the list decides the address and
+ * the caller only names the conversation. The brief is the fallback, and legal
+ * for any thread: a list with no thread route under it — the outbox — and a
+ * mailbox route in the frame before its id resolves both still open the
+ * conversation rather than doing nothing, which is the dead row this route shape
+ * exists to delete.
+ */
+export declare function useOpenThread(): (target: OpenThreadTarget, options?: OpenThreadOptions) => void;
+/**
+ * Close the conversation, landing back on the list it was opened from.
+ *
+ * A navigation up rather than a flag, so nothing is left mounted below the list
+ * and Esc unwinds exactly one step.
+ */
+export declare function useCloseThread(): () => void;

package/dist/src/routing/open-thread.js

@@ -0,0 +1,100 @@
+import { useNavigate, useParams } from "@tanstack/react-router";
+import { useCallback, useMemo } from "react";
+import { useBrowsedList, useNavigateToBrowsedList } from "./browsed-list";
+import { useRetainOpenPanels } from "./fragment";
+/**
+ * The thread the address has open, whichever list is browsing it.
+ *
+ * The thread is a child route of the list, and the list layout mounts the pane
+ * above the `Outlet` — so it asks the router which of its children matched
+ * rather than reading a param it does not own. A path matches one list at a
+ * time, so one hook answers for every list rather than each list keeping its
+ * own copy of the same question. Each `from` names a real route, so a segment
+ * that does not exist fails to compile.
+ */
+export function useOpenThreadPath() {
+    const briefThread = useParams({
+        from: "/mail/brief/$threadId",
+        shouldThrow: false,
+    });
+    const briefMessage = useParams({
+        from: "/mail/brief/$threadId/$messageId",
+        shouldThrow: false,
+    });
+    const flaggedThread = useParams({
+        from: "/mail/flagged/$threadId",
+        shouldThrow: false,
+    });
+    const flaggedMessage = useParams({
+        from: "/mail/flagged/$threadId/$messageId",
+        shouldThrow: false,
+    });
+    const mailboxThread = useParams({
+        from: "/mail/$mailboxId/$threadId",
+        shouldThrow: false,
+    });
+    const mailboxMessage = useParams({
+        from: "/mail/$mailboxId/$threadId/$messageId",
+        shouldThrow: false,
+    });
+    const threadId = briefThread?.threadId ?? flaggedThread?.threadId ?? mailboxThread?.threadId;
+    const messageId = briefMessage?.messageId ??
+        flaggedMessage?.messageId ??
+        mailboxMessage?.messageId;
+    return useMemo(() => (threadId ? { threadId, messageId } : undefined), [threadId, messageId]);
+}
+/**
+ * Open a conversation on the list the reader is browsing.
+ *
+ * The thread is a child route of its list, so the list decides the address and
+ * the caller only names the conversation. The brief is the fallback, and legal
+ * for any thread: a list with no thread route under it — the outbox — and a
+ * mailbox route in the frame before its id resolves both still open the
+ * conversation rather than doing nothing, which is the dead row this route shape
+ * exists to delete.
+ */
+export function useOpenThread() {
+    const navigate = useNavigate();
+    const retainPanels = useRetainOpenPanels();
+    const { list, mailboxId: browsedMailboxId } = useBrowsedList();
+    return useCallback((target, options) => {
+        const query = options?.query;
+        const search = (prev) => query === undefined ? prev : { ...prev, q: query || undefined };
+        const rest = {
+            search,
+            hash: retainPanels,
+            replace: options?.replace ?? false,
+        };
+        if (list === "flagged") {
+            navigate({
+                to: "/mail/flagged/$threadId/$messageId",
+                params: target,
+                ...rest,
+            });
+            return;
+        }
+        const mailboxId = options?.mailboxId ?? browsedMailboxId;
+        if (list === "mailbox" && mailboxId) {
+            navigate({
+                to: "/mail/$mailboxId/$threadId/$messageId",
+                params: { mailboxId, ...target },
+                ...rest,
+            });
+            return;
+        }
+        navigate({
+            to: "/mail/brief/$threadId/$messageId",
+            params: target,
+            ...rest,
+        });
+    }, [navigate, retainPanels, list, browsedMailboxId]);
+}
+/**
+ * Close the conversation, landing back on the list it was opened from.
+ *
+ * A navigation up rather than a flag, so nothing is left mounted below the list
+ * and Esc unwinds exactly one step.
+ */
+export function useCloseThread() {
+    return useNavigateToBrowsedList();
+}

package/dist/src/routing/outbox-draft.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The outbox message the reader has open, read off the path.
+ *
+ * The message is a child route of the list, and the list layout mounts the
+ * panes above the `Outlet` — so it asks the router which of its children
+ * matched rather than reading a param it does not own. The `from` names a real
+ * route, so a segment that does not exist fails to compile.
+ */
+export declare function useOutboxDraftId(): string | undefined;
+/** Open an outbox message in the reading pane. */
+export declare function useOpenOutboxDraft(): (outboxMessageId: string) => void;
+/** Close it again, landing back on the outbox. */
+export declare function useCloseOutboxDraft(): () => void;

package/dist/src/routing/outbox-draft.js

@@ -0,0 +1,37 @@
+import { useNavigate, useParams } from "@tanstack/react-router";
+import { useCallback } from "react";
+import { withoutComposeSeed } from "../lib/mail-search";
+import { useNavigateToBrowsedList } from "./browsed-list";
+import { useRetainOpenPanels } from "./fragment";
+/**
+ * The outbox message the reader has open, read off the path.
+ *
+ * The message is a child route of the list, and the list layout mounts the
+ * panes above the `Outlet` — so it asks the router which of its children
+ * matched rather than reading a param it does not own. The `from` names a real
+ * route, so a segment that does not exist fails to compile.
+ */
+export function useOutboxDraftId() {
+    const draft = useParams({
+        from: "/mail/outbox/draft/$outboxMessageId",
+        shouldThrow: false,
+    });
+    return draft?.outboxMessageId;
+}
+/** Open an outbox message in the reading pane. */
+export function useOpenOutboxDraft() {
+    const navigate = useNavigate();
+    const retainPanels = useRetainOpenPanels();
+    return useCallback((outboxMessageId) => {
+        navigate({
+            to: "/mail/outbox/draft/$outboxMessageId",
+            params: { outboxMessageId },
+            search: withoutComposeSeed,
+            hash: retainPanels,
+        });
+    }, [navigate, retainPanels]);
+}
+/** Close it again, landing back on the outbox. */
+export function useCloseOutboxDraft() {
+    return useNavigateToBrowsedList();
+}

package/dist/src/routing/reply.d.ts

@@ -0,0 +1,102 @@
+import { type ComposeSeed } from "../lib/mail-search";
+/**
+ * The three ways to answer a message. They are one path param rather than three
+ * literal routes, so the reply is one address shape and the mode is a value the
+ * composer reads.
+ */
+export declare const replyModes: readonly ["reply", "reply-all", "forward"];
+export type ReplyMode = (typeof replyModes)[number];
+/** The conversation and the turn inside it that a reply answers. */
+export interface ReplyTarget {
+    threadId: string;
+    messageId: string;
+    mode: ReplyMode;
+}
+/**
+ * The reply the address names.
+ *
+ * `unknown` is a hand-typed segment naming no mode. It is a case rather than a
+ * throw because the conversation behind it is still open and readable, and the
+ * pane says so where the composer would have been.
+ */
+export interface ReplyAddress {
+    mode: ReplyMode;
+    threadId: string;
+    /** The message being answered, which is the segment above this one. */
+    sourceMessageId: string;
+    /** The draft it writes to, once the first autosave has made one. */
+    outboxMessageId: string | undefined;
+    seed: ComposeSeed | undefined;
+}
+export type ReplySurface = ({
+    kind: "reply";
+} & ReplyAddress) | {
+    kind: "unknown";
+    segment: string;
+};
+/**
+ * The reply surface the address names, or none.
+ *
+ * The mode and the message it answers are both segments, so a reply cannot
+ * exist without a source and neither fact has a second owner. The draft is the
+ * segment under them, so a reload comes back to what was being written instead
+ * of starting a second draft beside it.
+ */
+export declare function useReplySurface(): ReplySurface | undefined;
+/**
+ * Whether a composer is open inside the conversation.
+ *
+ * The list's keyboard layer suspends on this: with a reply up, r, R and f are
+ * the composer's business, and a list still answering them would restart the
+ * reply on screen — or aim one at whichever row the cursor happens to be on.
+ * A segment naming no mode does not count: there is no composer to protect, and
+ * r is then the way out of a hand-typed address.
+ */
+export declare function useIsReplying(): boolean;
+/**
+ * Answer a message: the mode and the turn it answers, as one navigation.
+ *
+ * The message travels with the mode, so replying from a row the address had not
+ * named yet opens the conversation on it and the composer over it in the same
+ * transition — there is no "open it first, then reply" for the second half to
+ * be dropped from.
+ *
+ * A push, so Back leaves the reply and returns the message it was written
+ * under, and the query travels with it.
+ */
+export declare function useOpenReply(): (target: ReplyTarget, seed?: ComposeSeed) => void;
+/**
+ * Answer the conversation a list has open, from the segments naming it.
+ *
+ * The thread and the turn being answered are both in the path, so this is the
+ * address answering for itself: a listing row still in flight cannot make the
+ * verbs wait, and a thread request that fails outright cannot take them away.
+ * Reading the thread id back off a fetched row was the same fact in two places.
+ *
+ * A plain function rather than a hook, because every list already holds both
+ * values and the router state behind them. Reaching for them again here would
+ * subscribe each pane to the router a second time, and a pane re-rendering on
+ * every address change is felt by everything it wraps.
+ *
+ * `messageId` is the one thing the address can be silent about — a bare thread
+ * address leaves which turn answers for the conversation to the thread, so the
+ * caller passes the newest one once it knows. Absent until then, which is the
+ * toolbar's to explain.
+ */
+export declare function replyToThread(openReply: (target: ReplyTarget) => void, threadId: string | undefined, messageId: string | undefined): ((mode: ReplyMode) => void) | undefined;
+/**
+ * Record the draft the reply just created, in the address.
+ *
+ * A replace, and every panel left alone: the reader started one message, so the
+ * draft arriving under it is neither another step of history nor a move away
+ * from what they have open over the conversation.
+ */
+export declare function useAdoptReplyDraft(): (outboxMessageId: string) => void;
+/**
+ * Close the reply, landing back on the message it was answering.
+ *
+ * A push, like opening it: dismissing a surface moves the reader on, and Back
+ * is how they undo that. The conversation stayed matched behind the reply, so
+ * this drops the segments below it rather than rebuilding an address.
+ */
+export declare function useCloseReply(): () => void;