@burdenoff/fe-libs 2026.1029.3 → 2026.1029.4

package/dist/shared/assistant/ui/composer/AssistantModeMenu.d.ts

@@ -0,0 +1,51 @@
+import { FC } from 'react';
+import { AssistantModeConfig } from '../../conversation';
+import { AssistantTr } from '../../i18n';
+import { AssistantMode } from '../../types';
+import { AssistantAutoOption } from './AssistantModeSelector';
+/** Why the Mode menu cannot be used right now (linked to the trigger by `aria-describedby`). */
+export type AssistantModeDisabledReason = 'replying' | 'busy';
+export interface AssistantModeMenuProps {
+    mode: AssistantMode;
+    /** Role-filtered list of modes the user may pick (admin-gated modes removed). */
+    availableModes: AssistantModeConfig[];
+    onModeChange: (mode: AssistantMode) => void;
+    /** Offer Auto as the first option. Absent where Auto is not offered. */
+    auto?: AssistantAutoOption;
+    disabled?: boolean;
+    /** Why it is disabled. Ignored while enabled. Absent while disabled: `busy`. */
+    disabledReason?: AssistantModeDisabledReason | null;
+}
+/** A mode's name, exactly as its classic pill names it: the translated product label. */
+export declare function assistantModeOptionName(tr: AssistantTr, modeConfig: Pick<AssistantModeConfig, 'id'> & Partial<Pick<AssistantModeConfig, 'label' | 'producesArtifacts'>>): string;
+/**
+ * The compact presentation's Mode control (BOFF-10055, Slice 1): an APG menu
+ * button over the fe-libs `DropdownMenu` radio primitives. The selected option
+ * is always visible on the trigger, so the person always knows which mode a
+ * message goes to (D6).
+ *
+ * Keyboard (RECONCILIATION §D, `modeMenuKeys.ts`):
+ *  - Enter, Space or ↓ open with focus on the checked option; ↑ on the last;
+ *  - ↑/↓ browse and wrap, Home/End jump, and nothing but Enter, Space or a
+ *    click CHOOSES. The classic pills commit on every arrow press (F-02);
+ *  - Escape closes without a change and focus returns to the trigger;
+ *  - Tab and Shift+Tab close without a change and move on to the next or
+ *    previous focusable element. Radix keeps an open menu on Tab
+ *    (`preventDefault`), so the items take Tab first.
+ *
+ * ★ Choosing goes through the SAME callbacks the classic pills call
+ * (`onModeChange`, `auto.onSelect`), once. Choosing the option already selected
+ * changes nothing and calls nothing.
+ *
+ * ★ Disabled is `aria-disabled`, not `disabled`: the trigger stays in the Tab
+ * order so a keyboard or screen-reader user reaches it and hears WHY
+ * (`aria-describedby`), and it cannot open.
+ *
+ * ★ Non-modal (`modal={false}`): the assistant panel is non-modal, so the page
+ * behind stays reachable, and nothing else is hidden from assistive technology
+ * while the menu is open.
+ *
+ * With one mode and no Auto there is nothing to choose: a static label, with no
+ * role and no Tab stop, says which mode is in use.
+ */
+export declare const AssistantModeMenu: FC<AssistantModeMenuProps>;

package/dist/shared/assistant/ui/composer/AssistantModeMenu.js

@@ -0,0 +1,188 @@
+import { DropdownMenu as e, DropdownMenuContent as t, DropdownMenuRadioGroup as n, DropdownMenuRadioItem as r, DropdownMenuTrigger as i } from "../../../../ui/dropdown-menu.js";
+import { focusWasDropped as a } from "../../../hooks/useReturnFocus.js";
+import { useAssistantTr as o } from "../../i18n.js";
+import { AUTO_WRITE_MODE as s } from "../../autoRouting.js";
+import { assistantModeShortDescriptionKey as ee, translateProductCopy as te } from "../../productCopy.js";
+import { AUTO_MODE_OPTION_ID as c, assistantModeMeta as l } from "./AssistantModeSelector.js";
+import { TAB_STOP_SELECTOR as u, modeMenuItemKey as d, modeMenuOpenIndex as ne, modeMenuTriggerKey as f, nextTabStop as re } from "./modeMenuKeys.js";
+import { useCallback as p, useId as m, useRef as h, useState as g } from "react";
+import { ChevronDown as ie, Wand2 as ae } from "lucide-react";
+import { Fragment as _, jsx as v, jsxs as y } from "react/jsx-runtime";
+//#region src/shared/assistant/ui/composer/AssistantModeMenu.tsx
+function b(e, t) {
+	return e(`mode.${t.id}`, t.label || l(t).fallback);
+}
+var oe = "[data-radix-focus-guard],[data-radix-menu-content]";
+function se(e) {
+	if (e.disabled === !0 || e.getAttribute("type") === "hidden" || e.closest("[inert],[hidden]")) return !0;
+	let t = e.checkVisibility;
+	return typeof t == "function" ? !t.call(e) : !1;
+}
+var x = ({ mode: x, availableModes: S, onModeChange: C, auto: w, disabled: T = !1, disabledReason: E = null }) => {
+	let D = o(), O = m(), k = m(), [A, j] = g(!1);
+	A && T && j(!1);
+	let M = h(null), N = h([]), P = h("checked"), F = h(!1), I = w !== void 0, L = [...I ? [c] : [], ...S.map((e) => e.id)], R = w?.active ? c : x, z = L.indexOf(R), B = !!w?.active && x === "api-calls", V = S.find((e) => e.id === s), H = D("modeSelector.auto", "Auto"), U = D("modeSelector.autoHint", "Answers your questions, and proposes changes for you to approve"), W = S.find((e) => e.id === x), G = B && V ? b(D, V) : null, K = w?.active ? G ? `${H} · ${G}` : H : b(D, W ?? { id: x }), q = p((e) => {
+		if (e === R) return;
+		if (e === ":auto") {
+			w?.onSelect();
+			return;
+		}
+		let t = S.find((t) => t.id === e);
+		t && C(t.id);
+	}, [
+		w,
+		S,
+		C,
+		R
+	]), ce = p((e) => {
+		e && T || (e ? F.current = !0 : P.current = "checked", j(e));
+	}, [T]), le = p((e) => {
+		let t = f(e.key);
+		if (t !== null) {
+			if (T) {
+				e.preventDefault();
+				return;
+			}
+			P.current = t, e.key === "ArrowUp" && (e.preventDefault(), F.current = !0, j(!0));
+		}
+	}, [T]), J = p((e) => {
+		T && e.preventDefault();
+	}, [T]), Y = p((e) => {
+		let t = M.current;
+		if (j(!1), !t) return;
+		let n = t.ownerDocument, r = Array.from(n.querySelectorAll(u)).filter((e) => !N.current.includes(e) && !e.closest(oe)), i = r.indexOf(t);
+		(r[i < 0 ? -1 : re(r.map((e) => ({
+			tabIndex: e.tabIndex,
+			unreachable: se(e)
+		})), i, e)] ?? t).focus();
+	}, []), X = p((e) => {
+		if (e.defaultPrevented) return;
+		let t = N.current.slice(0, L.length), n = t.findIndex((t) => t !== null && t === e.target), r = d(e.key, {
+			shiftKey: e.shiftKey,
+			index: n,
+			count: L.length
+		});
+		r.kind === "move" ? (e.preventDefault(), t[r.index]?.focus()) : r.kind === "tab-out" && (e.preventDefault(), Y(r.direction));
+	}, [L.length, Y]), ue = p((e) => {
+		if (!F.current || e.target !== e.currentTarget) return;
+		F.current = !1, e.preventDefault();
+		let t = ne(P.current, z, L.length);
+		P.current = "checked", N.current[t]?.focus();
+	}, [z, L.length]), de = p((e) => {
+		let t = M.current;
+		t && !a(t.ownerDocument) && e.preventDefault();
+	}, []), fe = p((e) => {
+		M.current?.focus(), q(e);
+	}, [q]);
+	if (L.length === 0) return null;
+	if (L.length === 1) return /* @__PURE__ */ v("span", {
+		className: "inline-flex h-9 items-center px-3 text-sm text-text-secondary",
+		"data-testid": "assistant-mode-static",
+		children: D("modeMenu.staticLabel", "Mode: {{mode}}", { mode: K })
+	});
+	let Z = E === "replying" ? D("modeMenu.disabledReplying", "Mode can't change while the assistant is replying. Stop the reply to change it.") : D("modeMenu.disabledBusy", "Mode can't change right now."), pe = w?.active ? ae : l({ id: x }).icon, Q = "min-h-11 items-start gap-0 py-2 pr-3", $ = (e) => (t) => {
+		N.current[e] = t;
+	};
+	return /* @__PURE__ */ y(_, { children: [/* @__PURE__ */ y(e, {
+		open: A,
+		onOpenChange: ce,
+		modal: !1,
+		children: [/* @__PURE__ */ v(i, {
+			asChild: !0,
+			children: /* @__PURE__ */ y("button", {
+				ref: M,
+				type: "button",
+				"aria-label": D("modeMenu.trigger", "Assistant mode: {{mode}}", { mode: K }),
+				"aria-disabled": T || void 0,
+				"aria-describedby": T ? O : void 0,
+				title: T ? Z : void 0,
+				onKeyDown: le,
+				onPointerDown: J,
+				className: `inline-flex h-9 min-w-0 items-center gap-2 rounded-full pl-3 pr-2 text-sm font-medium text-text-primary transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-focus-ring)] ${T ? "cursor-not-allowed opacity-50" : "hover:bg-bg-surface"}`,
+				"data-testid": "assistant-mode-selector",
+				children: [
+					/* @__PURE__ */ v(pe, {
+						className: "size-4 shrink-0 text-text-secondary",
+						"aria-hidden": "true"
+					}),
+					/* @__PURE__ */ v("span", {
+						className: "truncate",
+						children: K
+					}),
+					/* @__PURE__ */ v(ie, {
+						className: "size-4 shrink-0 text-text-muted",
+						"aria-hidden": "true"
+					})
+				]
+			})
+		}), /* @__PURE__ */ v(t, {
+			side: "top",
+			align: "start",
+			sideOffset: 8,
+			collisionPadding: 8,
+			onFocus: ue,
+			onCloseAutoFocus: de,
+			onKeyDown: X,
+			className: "w-72 max-w-[calc(100vw-2rem)] max-h-[var(--radix-dropdown-menu-content-available-height)] overflow-y-auto",
+			"data-testid": "assistant-mode-menu",
+			children: /* @__PURE__ */ y(n, {
+				value: R,
+				onValueChange: fe,
+				children: [I ? /* @__PURE__ */ v(r, {
+					ref: $(0),
+					value: c,
+					onKeyDown: X,
+					"aria-labelledby": `${k}-label-0`,
+					"aria-describedby": `${k}-description-0`,
+					className: Q,
+					"data-testid": "assistant-mode-auto",
+					"data-auto-routed": B ? s : void 0,
+					children: /* @__PURE__ */ y("span", {
+						className: "flex min-w-0 flex-col",
+						children: [/* @__PURE__ */ v("span", {
+							id: `${k}-label-0`,
+							className: "font-medium",
+							children: H
+						}), /* @__PURE__ */ v("span", {
+							id: `${k}-description-0`,
+							className: "text-xs text-text-secondary",
+							"data-testid": "assistant-mode-description",
+							children: U
+						})]
+					})
+				}) : null, S.map((e, t) => {
+					let n = t + +!!I, i = e.shortDescription?.trim() ? te(D, ee(e.id), e.shortDescription) : null;
+					return /* @__PURE__ */ v(r, {
+						ref: $(n),
+						value: e.id,
+						onKeyDown: X,
+						"aria-labelledby": `${k}-label-${n}`,
+						"aria-describedby": i ? `${k}-description-${n}` : void 0,
+						className: Q,
+						"data-testid": `assistant-mode-option-${e.id}`,
+						children: /* @__PURE__ */ y("span", {
+							className: "flex min-w-0 flex-col",
+							children: [/* @__PURE__ */ v("span", {
+								id: `${k}-label-${n}`,
+								className: "font-medium",
+								children: b(D, e)
+							}), i ? /* @__PURE__ */ v("span", {
+								id: `${k}-description-${n}`,
+								className: "text-xs text-text-secondary",
+								"data-testid": "assistant-mode-description",
+								children: i
+							}) : null]
+						})
+					}, e.id);
+				})]
+			})
+		})]
+	}), T ? /* @__PURE__ */ v("span", {
+		id: O,
+		className: "sr-only",
+		"data-testid": "assistant-mode-disabled-reason",
+		children: Z
+	}) : null] });
+};
+//#endregion
+export { x as AssistantModeMenu, b as assistantModeOptionName };

package/dist/shared/assistant/ui/composer/imeEnter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * IME-safe Enter for the COMPACT composer (BOFF-10055, Slice 1).
+ *
+ * People typing Japanese, Chinese, Hindi, Tamil and many other languages
+ * compose words through an input method editor (IME). While a composition is
+ * open, Enter belongs to the IME: it commits the candidate the person picked.
+ * A composer that sends on every Enter sends a half-written message instead.
+ *
+ * Two signals, because browsers disagree:
+ *  - `isComposing` is true on a keydown that happens inside a composition
+ *    (Chrome, Firefox, Edge);
+ *  - Safari fires the Enter that ENDS a composition after `compositionend`,
+ *    with `isComposing` already false but `keyCode` 229 ("Process"), which every
+ *    engine reports for a key the IME consumed.
+ *
+ * The same test the Avatar tab's ask box has always used
+ * (`ui/avatar/AvatarTabAskBox.tsx`, left untouched). The CLASSIC composer does
+ * not use it: classic behaviour is frozen, and changing it there needs its own
+ * approval (decision IME-C).
+ *
+ * Pure: no React, no DOM. Synthetic-event tests prove this logic only; real
+ * input methods are verified separately.
+ */
+/** The keyCode an input method reports for a key it consumed while composing. */
+export declare const IME_PROCESS_KEY_CODE = 229;
+/** The parts of a keydown this check reads: a React event, or a native one. */
+export interface ImeKeyEventLike {
+    readonly key?: string;
+    readonly keyCode?: number;
+    readonly isComposing?: boolean;
+    readonly nativeEvent?: {
+        readonly isComposing?: boolean;
+        readonly keyCode?: number;
+    };
+}
+/** Is this keydown a key an input method is still composing with? */
+export declare function isImeComposingEnter(event: ImeKeyEventLike): boolean;
+/**
+ * Should this keydown SEND the compact composer's message? Enter without Shift,
+ * and only when no input method owns the key.
+ */
+export declare function compactEnterSends(event: ImeKeyEventLike & {
+    readonly shiftKey?: boolean;
+}): boolean;

package/dist/shared/assistant/ui/composer/imeEnter.js

@@ -0,0 +1,11 @@
+//#region src/shared/assistant/ui/composer/imeEnter.ts
+var e = 229;
+function t(e) {
+	let t = e.nativeEvent;
+	return t?.isComposing === !0 || e.isComposing === !0 ? !0 : (t?.keyCode ?? e.keyCode) === 229;
+}
+function n(e) {
+	return e.key !== "Enter" || e.shiftKey === !0 ? !1 : !t(e);
+}
+//#endregion
+export { e as IME_PROCESS_KEY_CODE, n as compactEnterSends, t as isImeComposingEnter };

package/dist/shared/assistant/ui/composer/modeMenuKeys.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The compact Mode menu's keyboard contract (BOFF-10055, Slice 1), as pure
+ * decisions the component wires into the Radix menu.
+ *
+ * APG menu button with `menuitemradio` items (RECONCILIATION §D):
+ *  - on the trigger, Enter, Space or ↓ open the menu with focus on the CHECKED
+ *    item; ↑ opens it with focus on the LAST item;
+ *  - inside, ↑/↓ browse and wrap, Home/End jump, and NONE of them changes the
+ *    mode. This fixes F-02: the classic pills commit on every arrow press;
+ *  - Enter or Space chooses the focused option, once;
+ *  - Escape closes without a change and returns focus to the trigger;
+ *  - Tab and Shift+Tab close without a change and CONTINUE sequential
+ *    navigation to the next or previous focusable element. They do not return
+ *    to the trigger. Radix (2.1.16 and 2.1.24) calls `preventDefault()` on Tab
+ *    inside menu content and keeps the menu open, so the component handles Tab
+ *    itself, before Radix sees it.
+ *
+ * Pure: no React, no DOM.
+ */
+/** Where focus goes when the menu opens. */
+export type ModeMenuOpenFocus = 'checked' | 'last';
+/** What a key on the closed trigger does: open (and where focus lands), or nothing. */
+export declare function modeMenuTriggerKey(key: string): ModeMenuOpenFocus | null;
+/** The item index focus starts on: the checked item, else the first; or the last. */
+export declare function modeMenuOpenIndex(focus: ModeMenuOpenFocus, checkedIndex: number, count: number): number;
+/** What a key inside the open menu does. */
+export type ModeMenuItemKeyAction = 
+/** Move focus to `index`; the mode does not change. */
+{
+    kind: 'move';
+    index: number;
+}
+/** Choose the focused option (once). */
+ | {
+    kind: 'commit';
+}
+/** Close; focus returns to the trigger. */
+ | {
+    kind: 'close';
+}
+/** Close; focus continues to the next (`1`) or previous (`-1`) focusable element. */
+ | {
+    kind: 'tab-out';
+    direction: 1 | -1;
+}
+/** Not a key the menu handles. */
+ | {
+    kind: 'none';
+};
+/** The menu's decision for one key, given the focused item and how many there are. */
+export declare function modeMenuItemKey(key: string, options: {
+    shiftKey?: boolean;
+    index: number;
+    count: number;
+}): ModeMenuItemKeyAction;
+/**
+ * Selector for elements sequential (Tab) navigation can reach, before the
+ * `tabindex`, `disabled`, `inert` and visibility checks `nextTabStop` applies.
+ */
+export declare const TAB_STOP_SELECTOR: string;
+/** What `nextTabStop` needs to know about one candidate. */
+export interface TabStopCandidate {
+    readonly tabIndex: number;
+    /** Disabled, inside an inert subtree, hidden, or a `type="hidden"` input. */
+    readonly unreachable: boolean;
+}
+/**
+ * The index, in DOCUMENT ORDER, of the element Tab (`direction` 1) or
+ * Shift+Tab (`-1`) moves to from the element at `fromIndex`, or -1 when there
+ * is none (the browser then leaves the page, which this code does not imitate).
+ *
+ * Only `tabIndex >= 0` and reachable candidates count. Positive tabindex
+ * ordering is not modelled: the assistant uses none, and document order is
+ * what such pages already get.
+ */
+export declare function nextTabStop(candidates: readonly TabStopCandidate[], fromIndex: number, direction: 1 | -1): number;

package/dist/shared/assistant/ui/composer/modeMenuKeys.js

@@ -0,0 +1,61 @@
+//#region src/shared/assistant/ui/composer/modeMenuKeys.ts
+function e(e) {
+	switch (e) {
+		case "Enter":
+		case " ":
+		case "ArrowDown": return "checked";
+		case "ArrowUp": return "last";
+		default: return null;
+	}
+}
+function t(e, t, n) {
+	return n <= 0 ? -1 : e === "last" ? n - 1 : t >= 0 && t < n ? t : 0;
+}
+function n(e, t) {
+	let { index: n, count: r } = t, i = r - 1;
+	switch (e) {
+		case "ArrowDown": return {
+			kind: "move",
+			index: n >= i ? 0 : n + 1
+		};
+		case "ArrowUp": return {
+			kind: "move",
+			index: n <= 0 ? i : n - 1
+		};
+		case "Home": return {
+			kind: "move",
+			index: 0
+		};
+		case "End": return {
+			kind: "move",
+			index: i
+		};
+		case "Enter":
+		case " ": return { kind: "commit" };
+		case "Escape": return { kind: "close" };
+		case "Tab": return {
+			kind: "tab-out",
+			direction: t.shiftKey === !0 ? -1 : 1
+		};
+		default: return { kind: "none" };
+	}
+}
+var r = [
+	"a[href]",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"summary",
+	"[tabindex]",
+	"[contenteditable=\"true\"]"
+].join(",");
+function i(e, t, n) {
+	for (let r = t + n; r >= 0 && r < e.length; r += n) {
+		let t = e[r];
+		if (t && t.tabIndex >= 0 && !t.unreachable) return r;
+	}
+	return -1;
+}
+//#endregion
+export { r as TAB_STOP_SELECTOR, n as modeMenuItemKey, t as modeMenuOpenIndex, e as modeMenuTriggerKey, i as nextTabStop };

package/dist/shared/assistant/ui/composer/modeSwitchPlan.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What switching the assistant's mode would do, decided BEFORE it is done
+ * (BOFF-10055, Slice 1: the D7 confirmation merged with first-time write
+ * consent). COMPACT presentation only; classic switches as it always has.
+ *
+ * A switch can cost the person something they cannot see from the menu:
+ *  - changes waiting for their approval are WITHDRAWN (`mode_switched`);
+ *  - a conversation with history is left in History and the new mode CONTINUES
+ *    IN ANOTHER CONVERSATION.
+ * When either is true, or the target is a write-capable mode this profile has
+ * not consented to yet, ONE dialog asks first. Never two: consent and the
+ * switch confirmation are one decision.
+ *
+ * ★★ The predicates are the ones the switch itself uses, so the dialog can
+ * never promise something the switch then does differently
+ * (`AssistantChatArea.tsx`, guarded by `modeSwitchPlan.test.ts`):
+ *  - a MODE pick (`performModeChange`): withdraw when the open conversation's
+ *    mode differs from the target; move when it also has history
+ *    (`conversationHasHistory`);
+ *  - consent (`handleModeChange`): the target is `writeCapable` and not in
+ *    `acknowledgedWriteModes`;
+ *  - AUTO (`handleSelectAuto`): nothing happens to a conversation Auto already
+ *    routes, or to one without history (it is adopted in place); one with
+ *    history whose mode the person chose is withdrawn from and left. Auto never
+ *    asks for consent here: a write is consented to when Auto routes a send.
+ *
+ * The draft is never lost by a switch (the composer is not remounted), so it is
+ * not a reason to ask; when the dialog shows anyway, it says the draft stays.
+ *
+ * Pure: no React, no store.
+ */
+/** The open conversation, as the switch reads it; `null` when none is open. */
+export interface ModeSwitchConversation {
+    /** The conversation's own mode. */
+    readonly mode: string;
+    /** `conversationHasHistory(conversation)`. */
+    readonly hasHistory: boolean;
+    /** `conversation.routedBy === 'auto'`. */
+    readonly routedByAuto: boolean;
+}
+export type ModeSwitchTarget = 
+/** A mode picked by hand. */
+{
+    readonly kind: 'mode';
+    readonly mode: string;
+    readonly consentRequired: boolean;
+}
+/** Auto (BOFF-7800). */
+ | {
+    readonly kind: 'auto';
+};
+export interface ModeSwitchInput {
+    readonly target: ModeSwitchTarget;
+    readonly conversation: ModeSwitchConversation | null;
+    /** Changes of the open conversation waiting for approval (`liveFor(id).count`). */
+    readonly waitingCount: number;
+    /** The composer holds text or attachments. */
+    readonly hasDraft: boolean;
+}
+export interface ModeSwitchPlan {
+    /** Ask before switching: consent applies, or something would be withdrawn or left. */
+    readonly needsDialog: boolean;
+    /** First-time write consent for the target mode. */
+    readonly consent: boolean;
+    /** Waiting changes the switch withdraws. */
+    readonly withdrawnCount: number;
+    /** The open conversation stays in History and the target continues in another one. */
+    readonly movesToNewConversation: boolean;
+    /** Say that the typed draft stays (only shown alongside a withdraw or a move). */
+    readonly draftKept: boolean;
+}
+/** What a switch to `input.target` would do, and whether to ask first. */
+export declare function planModeSwitch(input: ModeSwitchInput): ModeSwitchPlan;

package/dist/shared/assistant/ui/composer/modeSwitchPlan.js

@@ -0,0 +1,25 @@
+//#region src/shared/assistant/ui/composer/modeSwitchPlan.ts
+var e = {
+	needsDialog: !1,
+	consent: !1,
+	withdrawnCount: 0,
+	movesToNewConversation: !1,
+	draftKept: !1
+};
+function t(t) {
+	let { target: n, conversation: r } = t, i = Math.max(0, Math.floor(t.waitingCount)), a, o, s = !1;
+	if (n.kind === "mode") {
+		let e = r !== null && r.mode !== n.mode;
+		o = e, a = e && r.hasHistory, s = n.consentRequired;
+	} else a = r !== null && !r.routedByAuto && r.hasHistory, o = a;
+	let c = o ? i : 0, l = c > 0 || a;
+	return !l && !s ? e : {
+		needsDialog: !0,
+		consent: s,
+		withdrawnCount: c,
+		movesToNewConversation: a,
+		draftKept: l && t.hasDraft
+	};
+}
+//#endregion
+export { t as planModeSwitch };