teksilo_widgets/

message_box.rs

// SPDX-License-Identifier: MPL-2.0
// SPDX-FileCopyrightText: 2026 FernTech

//! MessageBox — QMessageBox-style alert dialog.
//!
//! A higher-level surface built on top of [`ModalContainer`]
//! for the classic "tell the user something and ask for a response"
//! pattern: unsaved-changes prompts, error surfaces, confirmation
//! dialogs, and informational notices. Mirrors QMessageBox (Qt),
//! NSAlert (AppKit), and SwiftUI's `.alert(...)` while staying inside
//! Teksilo's idioms — closure result handlers, `Signal`/`Prop`
//! reactivity, `Intent`/`Action`/`Shortcut` routing for keyboard
//! defaults, and AccessKit `Role::AlertDialog` accessibility.
//!
//! ## Quick tour
//!
//! ```ignore
//! use teksilo::prelude::*;
//! use teksilo::widgets::{MessageBox, MessageBoxButtons, StandardButton};
//!
//! fn on_close(ctx: &mut EventContext) {
//!     MessageBox::question(lit!("Save changes?"))
//!         .text(lit!("You have unsaved changes in report.skrib."))
//!         .informative_text(lit!("Your changes will be lost if you don't save them."))
//!         .buttons(MessageBoxButtons::SaveDiscardCancel)
//!         .default_button(StandardButton::Save)
//!         .escape_button(StandardButton::Cancel)
//!         .on_result(|r, ctx| match r.button {
//!             StandardButton::Save => save_and_close(ctx),
//!             StandardButton::Discard => close(ctx),
//!             _ => {}
//!         })
//!         .present(ctx);
//! }
//! # fn save_and_close(_: &mut EventContext) {}
//! # fn close(_: &mut EventContext) {}
//! ```
//!
//! ## Severity
//!
//! [`MessageBoxSeverity`] controls the icon drawn beside the title and
//! its tint:
//!
//! - `Information` — info glyph, `status_info_fg` tint.
//! - `Question` — question mark glyph, `accent` tint.
//! - `Warning` — exclamation triangle, `status_warning_fg` tint.
//! - `Critical` — X-mark circle, `status_error_fg` tint. Also disables
//!   click-outside dismissal (Qt convention).
//! - `None` — no icon, no tint.
//!
//! Severity is conveyed through the icon + title + text. Per Teksilo's
//! Int UI baseline, buttons are **never** colored as "destructive":
//! destructive intent lives in the dialog's severity and wording, not
//! in the button. See [`crate::button`] for details.
//!
//! ## Default & escape buttons
//!
//! - `default_button` — activated by Enter (widget-scoped shortcut) and
//!   receives initial focus on open (via `ModalRequest::focus_target`
//!   plus `Widget::initial_focus_hint`). Styled with
//!   `ButtonVariant::Filled`.
//! - `escape_button` — activated by Escape. The fallback logic (for
//!   presets with no explicit `escape_button`) picks: explicit
//!   `escape_button` → first `Reject`-role button → `Cancel` → last
//!   button.
//!
//! Each preset supplies a default: Ok for `Ok` and `OkCancel`, Save for
//! `SaveDiscardCancel`, Retry for `RetryIgnoreAbort`, and **No** for
//! `YesNo` and `YesNoCancel`.
//!
//! The Yes/No default is the negative answer on purpose. An Ok/Cancel box
//! confirms something the user just asked for, so Ok is the answer they
//! meant. A Yes/No box asks a question they did not initiate, and it is
//! overwhelmingly asked before something irreversible — "Delete this?",
//! "Discard your changes?". Defaulting to Yes means Enter destroys, and
//! Enter is what a keyboard user presses on a dialog they have not
//! finished reading. Where the question is safe, `default_button` puts Yes
//! back in one reviewable line; the reverse default cannot be reviewed,
//! because there is nothing on the screen to review.
//!
//! It matters more than it looks, because **no platform announces which
//! button is the default**: `Node::keyboard_shortcut` appears in none of
//! the three AccessKit adapters, so a screen-reader user discovers the
//! default only by pressing Enter. Where focus lands is the whole contract.
//!
//! ## Title and button alignment
//!
//! [`MessageBox::title_alignment`] places the title in the header's text
//! column (default `Leading`) and [`MessageBox::button_alignment`] places the
//! button row (default `Trailing`), both as [`teksilo_tokens::HAlignment`].
//! macOS alerts centre both; Windows and GNOME keep the title leading and the
//! buttons trailing, which is the default. `Leading` and `Trailing` follow the
//! layout direction.
//!
//! ## Result reporting
//!
//! [`MessageBox::on_result`] takes `impl Fn(MessageBoxResult,
//! &mut EventContext) + 'static`. The callback fires exactly once, whichever
//! route closes the dialog — button activation, Escape, a press outside, or a
//! programmatic dismissal — with [`MessageBoxResult::dismissal`] naming which
//! one. On a button activation the modal is then closed by the framework; on
//! the other routes it is already going away.
//!
//! ## Accessibility
//!
//! The widget exposes `Role::AlertDialog`, with `set_modal()`,
//! `set_live(Live::Assertive)`, `set_name(title)`, and
//! `set_description(text + informative_text)`, so screen readers
//! announce the dialog by its title as it opens and find the text as its
//! description and by walking it. The `ModalContainer` that presents it
//! publishes no dialog of its own around it, and the content under it is
//! `Live::Off`, so the title is the one thing announced, once.

use std::cell::{Cell, RefCell};
use std::rc::Rc;

use teksilo_canvas::{Rect, Size, SizeProposal};
use teksilo_core::accessibility::AccessNodeBuilder;
use teksilo_core::action::Action;
use teksilo_core::build_context::BuildContext;
use teksilo_core::event::{Key, Modifiers};
use teksilo_core::modal::{ModalCloseBehavior, ModalPresentation, ModalRequest};
use teksilo_core::shortcut::{KeyStroke, Shortcut};
use teksilo_core::signal::Signal;
use teksilo_core::widget::{EventContext, LayoutContext, PaintContext, Widget, WidgetPlacement};
use teksilo_core::widget_builder::WidgetBuilder;
use teksilo_core::widget_id::WidgetId;
use teksilo_i18n::LocalizedString;
use teksilo_tokens::{Alignment, HAlignment, InputTokens, TargetRole, VAlignment};

use crate::accordion::Accordion;
use crate::button::{Button, ButtonVariant};
use crate::checkbox::Checkbox;
use crate::dialog::ModalContainer;
use crate::primitives::{Expand, HStack, Spacer, TextWidget, VStack};
use crate::scroll_area::ScrollArea;
use crate::severity_badge::{SeverityBadge, SeverityIconKind};
use teksilo_core::styles::density::dp;

// ── Severity ────────────────────────────────────────────────────────

/// Alert severity level. Drives the icon glyph + tint shown beside the
/// title, and (for `Critical`) whether click-outside dismiss is enabled.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum MessageBoxSeverity {
    /// No icon. Use for plain notices where an icon would be noise.
    #[default]
    None,
    /// Informational notice — blue circle with "i" glyph.
    Information,
    /// Confirmation prompt — accent-tinted circle with "?" glyph.
    Question,
    /// Non-fatal warning — amber triangle with "!" glyph.
    Warning,
    /// Critical error — red circle with an "X" glyph. Click-outside
    /// dismissal is disabled (Escape still works).
    Critical,
}

// ── Standard button catalog ─────────────────────────────────────────

/// Semantic role of a message-box button. Used for fallback escape
/// resolution (`Reject` wins when no explicit escape button is set).
/// Teksilo deliberately does **not** render `Destructive` buttons with
/// a red fill — the dialog's severity icon and wording carry that
/// signal. See [`crate::button`] for the framework-level rationale.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ButtonRole {
    /// Confirms / proceeds. Ok, Yes, Save, Open, Apply, Retry.
    Accept,
    /// Bails out. Cancel, Close, No, Abort.
    Reject,
    /// Data-loss action. Discard. (Same visuals as Regular — the
    /// severity of the surrounding MessageBox carries the warning.)
    Destructive,
    /// Side action. Help, Reset, RestoreDefaults, Ignore, and the
    /// "to all" variants.
    Action,
}

/// The Qt-modeled catalog of standard buttons. Each variant resolves
/// to a localized label, a semantic [`ButtonRole`], and a stable
/// intent-name string used internally for shortcut/action routing.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum StandardButton {
    /// Accept / confirm. `ButtonRole::Accept`.
    Ok,
    /// Cancel the operation. `ButtonRole::Reject`.
    Cancel,
    /// Close the dialog. `ButtonRole::Reject`.
    Close,
    /// Confirm with "Yes". `ButtonRole::Accept`.
    Yes,
    /// Decline with "No". `ButtonRole::Reject`.
    No,
    /// Confirm all remaining items. `ButtonRole::Accept`.
    YesToAll,
    /// Decline all remaining items. `ButtonRole::Reject`.
    NoToAll,
    /// Save changes. `ButtonRole::Accept`.
    Save,
    /// Save all open items. `ButtonRole::Accept`.
    SaveAll,
    /// Discard changes without saving. `ButtonRole::Destructive`.
    Discard,
    /// Apply changes without closing. `ButtonRole::Accept`.
    Apply,
    /// Reset to defaults. `ButtonRole::Action`.
    Reset,
    /// Restore factory defaults. `ButtonRole::Action`.
    RestoreDefaults,
    /// Abort the current operation. `ButtonRole::Reject`.
    Abort,
    /// Retry the failed operation. `ButtonRole::Accept`.
    Retry,
    /// Ignore the error and continue. `ButtonRole::Action`.
    Ignore,
    /// Open a file or resource. `ButtonRole::Accept`.
    Open,
    /// Show help. `ButtonRole::Action`.
    Help,
}

impl StandardButton {
    /// The button's semantic role — used internally by MessageBox's
    /// escape-button fallback resolution, and available to callers that
    /// want to inspect a `MessageBoxButton`'s role.
    pub fn role(self) -> ButtonRole {
        match self {
            Self::Ok
            | Self::Yes
            | Self::YesToAll
            | Self::Save
            | Self::SaveAll
            | Self::Apply
            | Self::Retry
            | Self::Open => ButtonRole::Accept,
            Self::Cancel | Self::Close | Self::No | Self::NoToAll | Self::Abort => {
                ButtonRole::Reject
            }
            Self::Discard => ButtonRole::Destructive,
            Self::Reset | Self::RestoreDefaults | Self::Ignore | Self::Help => ButtonRole::Action,
        }
    }

    /// Stable string id used as both the shortcut id and the intent
    /// name for routing default/escape key activations. Scoped to a
    /// MessageBox instance via widget-scoped shortcut registration, so
    /// the same id is safe to reuse across instances.
    pub fn intent_name(self) -> &'static str {
        match self {
            Self::Ok => "messagebox.btn.ok",
            Self::Cancel => "messagebox.btn.cancel",
            Self::Close => "messagebox.btn.close",
            Self::Yes => "messagebox.btn.yes",
            Self::No => "messagebox.btn.no",
            Self::YesToAll => "messagebox.btn.yes_to_all",
            Self::NoToAll => "messagebox.btn.no_to_all",
            Self::Save => "messagebox.btn.save",
            Self::SaveAll => "messagebox.btn.save_all",
            Self::Discard => "messagebox.btn.discard",
            Self::Apply => "messagebox.btn.apply",
            Self::Reset => "messagebox.btn.reset",
            Self::RestoreDefaults => "messagebox.btn.restore_defaults",
            Self::Abort => "messagebox.btn.abort",
            Self::Retry => "messagebox.btn.retry",
            Self::Ignore => "messagebox.btn.ignore",
            Self::Open => "messagebox.btn.open",
            Self::Help => "messagebox.btn.help",
        }
    }

    /// Default label for the button. Resolved through the Fluent
    /// catalog via `tr_widget!` so apps can override per-locale.
    pub fn default_label(self) -> LocalizedString {
        match self {
            Self::Ok => teksilo_i18n::tr_widget!(messagebox_btn_ok()),
            Self::Cancel => teksilo_i18n::tr_widget!(messagebox_btn_cancel()),
            Self::Close => teksilo_i18n::tr_widget!(messagebox_btn_close()),
            Self::Yes => teksilo_i18n::tr_widget!(messagebox_btn_yes()),
            Self::No => teksilo_i18n::tr_widget!(messagebox_btn_no()),
            Self::YesToAll => teksilo_i18n::tr_widget!(messagebox_btn_yes_to_all()),
            Self::NoToAll => teksilo_i18n::tr_widget!(messagebox_btn_no_to_all()),
            Self::Save => teksilo_i18n::tr_widget!(messagebox_btn_save()),
            Self::SaveAll => teksilo_i18n::tr_widget!(messagebox_btn_save_all()),
            Self::Discard => teksilo_i18n::tr_widget!(messagebox_btn_discard()),
            Self::Apply => teksilo_i18n::tr_widget!(messagebox_btn_apply()),
            Self::Reset => teksilo_i18n::tr_widget!(messagebox_btn_reset()),
            Self::RestoreDefaults => teksilo_i18n::tr_widget!(messagebox_btn_restore_defaults()),
            Self::Abort => teksilo_i18n::tr_widget!(messagebox_btn_abort()),
            Self::Retry => teksilo_i18n::tr_widget!(messagebox_btn_retry()),
            Self::Ignore => teksilo_i18n::tr_widget!(messagebox_btn_ignore()),
            Self::Open => teksilo_i18n::tr_widget!(messagebox_btn_open()),
            Self::Help => teksilo_i18n::tr_widget!(messagebox_btn_help()),
        }
    }
}

/// A single button placement inside a MessageBox, including an optional
/// per-instance label override. Callers usually build these via
/// [`From<StandardButton>`] (`StandardButton::Ok.into()`), or
/// construct them manually when `Custom` is needed.
#[derive(Debug, Clone)]
pub struct MessageBoxButton {
    /// Which standard button this is — drives role, intent name, and
    /// (when `label_override` is `None`) the label.
    pub kind: StandardButton,
    /// Optional explicit label that overrides `kind.default_label()`.
    /// Use sparingly: prefer translating the default via Fluent rather
    /// than hard-coding per-call labels.
    pub label_override: Option<LocalizedString>,
}

impl MessageBoxButton {
    /// Build a button from a `StandardButton` with the default label.
    pub fn standard(kind: StandardButton) -> Self {
        Self {
            kind,
            label_override: None,
        }
    }

    /// Override the default translated label.
    pub fn label(mut self, label: impl Into<LocalizedString>) -> Self {
        self.label_override = Some(label.into());
        self
    }

    fn resolved_label(&self) -> LocalizedString {
        self.label_override
            .clone()
            .unwrap_or_else(|| self.kind.default_label())
    }
}

impl From<StandardButton> for MessageBoxButton {
    fn from(kind: StandardButton) -> Self {
        Self::standard(kind)
    }
}

/// Pre-built button bundles covering the common MessageBox shapes.
/// Custom combinations go through [`MessageBox::add_button`] or
/// [`MessageBoxButtons::Custom`].
#[derive(Debug, Clone)]
pub enum MessageBoxButtons {
    /// Just Ok.
    Ok,
    /// Ok + Cancel, Ok default, Cancel escape.
    OkCancel,
    /// Yes + No. **No** is the default, and No is the escape. See the module
    /// docs for why the default is the negative answer.
    YesNo,
    /// Yes + No + Cancel. **No** is the default, Cancel is the escape — Enter
    /// takes the safe answer to the question asked, Escape leaves the dialog.
    YesNoCancel,
    /// The unsaved-changes triad: Save + Discard + Cancel.
    SaveDiscardCancel,
    /// The error-recovery triad: Retry + Ignore + Abort.
    RetryIgnoreAbort,
    /// Explicit list. MessageBox preserves the order as the visual
    /// button order (leading Spacer pushes all buttons to the trailing
    /// edge; default button may appear anywhere).
    Custom(Vec<MessageBoxButton>),
}

impl MessageBoxButtons {
    fn into_buttons(self) -> Vec<MessageBoxButton> {
        match self {
            Self::Ok => vec![StandardButton::Ok.into()],
            Self::OkCancel => vec![StandardButton::Cancel.into(), StandardButton::Ok.into()],
            Self::YesNo => vec![StandardButton::No.into(), StandardButton::Yes.into()],
            Self::YesNoCancel => vec![
                StandardButton::Cancel.into(),
                StandardButton::No.into(),
                StandardButton::Yes.into(),
            ],
            Self::SaveDiscardCancel => vec![
                StandardButton::Discard.into(),
                StandardButton::Cancel.into(),
                StandardButton::Save.into(),
            ],
            Self::RetryIgnoreAbort => vec![
                StandardButton::Abort.into(),
                StandardButton::Ignore.into(),
                StandardButton::Retry.into(),
            ],
            Self::Custom(items) => items,
        }
    }

    /// Default button hint derived from the preset. Callers that want
    /// a different default override via `MessageBox::default_button`.
    ///
    /// `Ok` and `OkCancel` default to Ok because an Ok/Cancel box asks the user
    /// to confirm something they just asked for. `YesNo` and `YesNoCancel`
    /// default to **No**, because a Yes/No box asks a question the user did not
    /// initiate, and the answer that cannot be undone is Yes. See the variant
    /// docs.
    fn preset_default(&self) -> Option<StandardButton> {
        match self {
            Self::Ok => Some(StandardButton::Ok),
            Self::OkCancel => Some(StandardButton::Ok),
            Self::YesNo => Some(StandardButton::No),
            Self::YesNoCancel => Some(StandardButton::No),
            Self::SaveDiscardCancel => Some(StandardButton::Save),
            Self::RetryIgnoreAbort => Some(StandardButton::Retry),
            Self::Custom(_) => None,
        }
    }

    /// Escape button hint derived from the preset.
    fn preset_escape(&self) -> Option<StandardButton> {
        match self {
            Self::Ok => Some(StandardButton::Ok),
            Self::OkCancel => Some(StandardButton::Cancel),
            Self::YesNo => Some(StandardButton::No),
            Self::YesNoCancel => Some(StandardButton::Cancel),
            Self::SaveDiscardCancel => Some(StandardButton::Cancel),
            Self::RetryIgnoreAbort => Some(StandardButton::Abort),
            Self::Custom(_) => None,
        }
    }
}

// ── Result ──────────────────────────────────────────────────────────

/// How a [`MessageBox`] came to close.
///
/// This replaced a `dismissed_by_escape: bool` whose own rustdoc claimed to
/// cover scrim-click as well — a contract no code path could produce, because
/// the only writer was the Escape action. One field that names the route
/// cannot drift from its documentation the way two overlapping booleans can,
/// and the caller can finally tell "the user chose Cancel" from "the user
/// waved the dialog away", which for a Save/Discard/Cancel prompt are
/// different answers.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum MessageBoxDismissal {
    /// A button was chosen: clicked, or Enter on the default.
    Button,
    /// Escape, resolved to the escape button.
    Escape,
    /// A press outside the dialog, where its `ModalCloseBehavior` permits it.
    ClickOutside,
    /// It went away for another reason — the application dismissed it, or an
    /// enclosing surface closed and took it along. `button` still carries the
    /// escape-button resolution, because something has to be reported and
    /// that is the same answer Escape would have given.
    Programmatic,
}

/// Report passed to [`MessageBox::on_result`] when the dialog closes.
#[derive(Debug, Clone, Copy)]
pub struct MessageBoxResult {
    /// Which button fired — either by click, Enter (the focused button,
    /// else the default), or escape-button resolution for any of the
    /// dismissal routes.
    pub button: StandardButton,
    /// State of the "Don't show again" checkbox at dismiss time, when
    /// one was configured via [`MessageBox::show_again_checkbox`] or
    /// [`MessageBox::show_again_checkbox_state`]. `false` when no
    /// checkbox was attached.
    pub checkbox_checked: bool,
    /// Which route closed the dialog.
    pub dismissal: MessageBoxDismissal,
}

impl From<teksilo_core::overlay::DismissReason> for MessageBoxDismissal {
    fn from(reason: teksilo_core::overlay::DismissReason) -> Self {
        use teksilo_core::overlay::DismissReason as R;
        match reason {
            R::Escape => Self::Escape,
            R::OutsidePress => Self::ClickOutside,
            // A modal has no hover-out route, and the remaining reasons all
            // mean "something other than the user's hand closed this".
            _ => Self::Programmatic,
        }
    }
}

impl MessageBoxResult {
    /// Whether the dialog went away without the user choosing a button.
    ///
    /// The predicate the old `dismissed_by_escape` flag was reached for, minus
    /// the claim that Escape was the only way to get there.
    pub fn was_dismissed(&self) -> bool {
        self.dismissal != MessageBoxDismissal::Button
    }
}

const SEVERITY_ICON_SIZE: f32 = 48.0;

/// [`SEVERITY_ICON_SIZE`] raised to the density's `target_size`
/// (24 / 32 / 44 dp). The identity at Compact.
fn severity_icon_size(tokens: &InputTokens) -> f32 {
    dp(SEVERITY_ICON_SIZE, TargetRole::Target, tokens)
}

/// How tall the expanded "Show details" pane is allowed to grow before it scrolls.
///
/// `detailed_text` is where callers put the things that have no length bound — a stack
/// trace, an OS error dump, a list of every affected row — so without a cap the accordion
/// simply grew the dialog until it ran off the bottom of the screen, taking the buttons
/// with it. Tall enough for a dozen lines of `small` text, short enough that the dialog
/// still fits a laptop display beneath a header and a button row.
const DETAILS_MAX_HEIGHT: f32 = 220.0;

const DEFAULT_INTENT_NAME: &str = "messagebox.accept_default";
const ESCAPE_INTENT_NAME: &str = "messagebox.escape";

/// Map a `MessageBoxSeverity` onto the shared severity-badge kind.
/// `None` has no badge (the dialog reads as a plain notice).
fn severity_icon_kind(severity: MessageBoxSeverity) -> Option<SeverityIconKind> {
    match severity {
        MessageBoxSeverity::None => None,
        MessageBoxSeverity::Information => Some(SeverityIconKind::Info),
        MessageBoxSeverity::Question => Some(SeverityIconKind::Question),
        MessageBoxSeverity::Warning => Some(SeverityIconKind::Warning),
        MessageBoxSeverity::Critical => Some(SeverityIconKind::Error),
    }
}

// ── Internal runtime state ─────────────────────────────────────────

/// State shared between the MessageBox widget, its footer buttons, and
/// the Enter/Escape shortcut actions. Lives in an `Rc` so all three
/// dispatch paths can read/write the same checkbox state and fire the
/// same result callback exactly once per session.
struct State {
    on_result: RefCell<Option<Box<dyn Fn(MessageBoxResult, &mut EventContext)>>>,
    checkbox: Signal<bool>,
    escape_button: Cell<Option<StandardButton>>,
    default_button: Cell<Option<StandardButton>>,
    /// Fallback list of buttons in the order they were configured —
    /// consulted when neither `escape_button` nor a `Reject`-role
    /// button is set.
    buttons: RefCell<Vec<StandardButton>>,
    /// Every button this box built, by widget id. Read by the Enter
    /// shortcut so it can answer for the button the user is standing on
    /// rather than for the default. Rebuilt on every `build`.
    button_ids: RefCell<Vec<(WidgetId, StandardButton)>>,
    /// Guards against multiple result-callback invocations when a
    /// button click races the Escape shortcut.
    fired: Cell<bool>,
}

impl State {
    fn new(checkbox: Signal<bool>) -> Rc<Self> {
        Rc::new(Self {
            on_result: RefCell::new(None),
            checkbox,
            escape_button: Cell::new(None),
            default_button: Cell::new(None),
            buttons: RefCell::new(Vec::new()),
            button_ids: RefCell::new(Vec::new()),
            fired: Cell::new(false),
        })
    }

    /// Which of this box's buttons a widget id is, if it is one of them.
    fn button_for(&self, id: WidgetId) -> Option<StandardButton> {
        self.button_ids
            .borrow()
            .iter()
            .find(|(btn, _)| *btn == id)
            .map(|(_, kind)| *kind)
    }

    /// Report the answer and close the dialog. The path a button takes.
    fn fire(&self, button: StandardButton, dismissal: MessageBoxDismissal, ctx: &mut EventContext) {
        if self.report(button, dismissal, ctx) {
            ctx.dismiss_modal();
        }
    }

    /// Report the answer for a dialog that is **already being dismissed**, and
    /// return whether this call is the one that reported.
    ///
    /// Split from [`fire`](Self::fire) for the `on_dismiss` path: the overlay
    /// is mid-teardown there, and `ctx.dismiss_modal()` only sets a deferred
    /// flag — asking again would spend it on whatever modal is topmost when it
    /// is read, which for a dialog opened over another dialog means closing
    /// the wrong one.
    fn report(
        &self,
        button: StandardButton,
        dismissal: MessageBoxDismissal,
        ctx: &mut EventContext,
    ) -> bool {
        if self.fired.replace(true) {
            return false;
        }
        let result = MessageBoxResult {
            button,
            checkbox_checked: self.checkbox.get(),
            dismissal,
        };
        if let Some(handler) = self.on_result.borrow().as_ref() {
            handler(result, ctx);
        }
        true
    }

    fn resolve_escape_button(&self) -> Option<StandardButton> {
        if let Some(btn) = self.escape_button.get() {
            return Some(btn);
        }
        let buttons = self.buttons.borrow();
        if let Some(btn) = buttons.iter().find(|b| b.role() == ButtonRole::Reject) {
            return Some(*btn);
        }
        if buttons.contains(&StandardButton::Cancel) {
            return Some(StandardButton::Cancel);
        }
        buttons.last().copied()
    }
}

// ── The MessageBox widget ──────────────────────────────────────────

/// A modal alert dialog that displays a severity icon, title, body text, and
/// one or more buttons.
///
/// Constructed via severity-named constructors ([`MessageBox::information`],
/// [`MessageBox::warning`], [`MessageBox::critical`], [`MessageBox::question`],
/// [`MessageBox::plain`]), configured fluently, and presented with
/// [`MessageBox::present`]. See the module documentation for the full guide.
pub struct MessageBox {
    severity: MessageBoxSeverity,
    title: LocalizedString,
    text: Option<LocalizedString>,
    informative_text: Option<LocalizedString>,
    detailed_text: Option<LocalizedString>,
    buttons_config: Option<MessageBoxButtons>,
    extra_buttons: Vec<MessageBoxButton>,
    default_button: Option<StandardButton>,
    escape_button: Option<StandardButton>,
    show_again_label: Option<LocalizedString>,
    show_again_state: Option<Signal<bool>>,
    title_alignment: HAlignment,
    button_alignment: HAlignment,
    on_result: Option<Box<dyn Fn(MessageBoxResult, &mut EventContext)>>,
    default_button_id: Cell<Option<WidgetId>>,
    root_child_id: Option<WidgetId>,
    state: Option<Rc<State>>,
    /// Published by `build` so [`present`](Self::present)'s `on_dismiss` can
    /// reach the state. `present` moves `self` into a deferred builder that
    /// does not run until the modal is mounted, so the closure has to be
    /// handed a slot rather than the `State` itself.
    state_slot: Option<Rc<RefCell<Option<Rc<State>>>>>,
}

impl std::fmt::Debug for MessageBox {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MessageBox")
            .field("severity", &self.severity)
            .field("title", &self.title)
            .field("text", &self.text)
            .field("informative_text", &self.informative_text)
            .field("detailed_text", &self.detailed_text)
            .field("default_button", &self.default_button)
            .field("escape_button", &self.escape_button)
            .finish()
    }
}

impl MessageBox {
    fn new_with_severity(severity: MessageBoxSeverity, title: impl Into<LocalizedString>) -> Self {
        let title = title.into();
        Self {
            severity,
            title,
            text: None,
            informative_text: None,
            detailed_text: None,
            buttons_config: None,
            extra_buttons: Vec::new(),
            default_button: None,
            escape_button: None,
            show_again_label: None,
            show_again_state: None,
            title_alignment: HAlignment::Leading,
            button_alignment: HAlignment::Trailing,
            on_result: None,
            default_button_id: Cell::new(None),
            root_child_id: None,
            state: None,
            state_slot: None,
        }
    }

    /// Construct an informational MessageBox (`Information` severity).
    pub fn information(title: impl Into<LocalizedString>) -> Self {
        Self::new_with_severity(MessageBoxSeverity::Information, title)
    }

    /// Construct a warning MessageBox (`Warning` severity).
    pub fn warning(title: impl Into<LocalizedString>) -> Self {
        Self::new_with_severity(MessageBoxSeverity::Warning, title)
    }

    /// Construct a critical-error MessageBox (`Critical` severity).
    /// Click-outside dismissal is disabled; use an explicit button or
    /// Escape to close.
    pub fn critical(title: impl Into<LocalizedString>) -> Self {
        Self::new_with_severity(MessageBoxSeverity::Critical, title)
    }

    /// Construct a confirmation / question MessageBox (`Question`
    /// severity).
    pub fn question(title: impl Into<LocalizedString>) -> Self {
        Self::new_with_severity(MessageBoxSeverity::Question, title)
    }

    /// Construct a plain MessageBox with no severity icon.
    pub fn plain(title: impl Into<LocalizedString>) -> Self {
        Self::new_with_severity(MessageBoxSeverity::None, title)
    }

    /// Primary message line, rendered in `typography.body` with
    /// `text_primary`. Prefer a short, self-contained sentence —
    /// details belong in `informative_text`.
    pub fn text(mut self, text: impl Into<LocalizedString>) -> Self {
        self.text = Some(text.into());
        self
    }

    /// Secondary, explanatory text rendered below the primary text in
    /// `typography.body` with `text_secondary`. Matches Qt's
    /// `setInformativeText`.
    pub fn informative_text(mut self, text: impl Into<LocalizedString>) -> Self {
        self.informative_text = Some(text.into());
        self
    }

    /// Detailed text hidden behind a "Show details" [`Accordion`] —
    /// for technical diagnostics (stack traces, error codes). Matches
    /// Qt's `setDetailedText`.
    pub fn detailed_text(mut self, text: impl Into<LocalizedString>) -> Self {
        self.detailed_text = Some(text.into());
        self
    }

    /// Apply a preset button bundle. Implicitly sets default and
    /// escape buttons for the preset (both can be overridden via
    /// [`MessageBox::default_button`] and
    /// [`MessageBox::escape_button`]).
    pub fn buttons(mut self, preset: MessageBoxButtons) -> Self {
        if self.default_button.is_none() {
            self.default_button = preset.preset_default();
        }
        if self.escape_button.is_none() {
            self.escape_button = preset.preset_escape();
        }
        self.buttons_config = Some(preset);
        self
    }

    /// Append a single button. Use to augment a preset (rare) or to
    /// build a bespoke button row without going through
    /// [`MessageBoxButtons::Custom`].
    pub fn add_button(mut self, button: impl Into<MessageBoxButton>) -> Self {
        self.extra_buttons.push(button.into());
        self
    }

    /// Append several buttons from an iterator, in order.
    ///
    /// The loop form of [`add_button`](Self::add_button), for a bespoke button
    /// row built from data rather than spelled out one call at a time.
    pub fn add_buttons(
        self,
        buttons: impl IntoIterator<Item = impl Into<MessageBoxButton>>,
    ) -> Self {
        buttons.into_iter().fold(self, Self::add_button)
    }

    /// Mark which button activates on Enter and receives initial
    /// focus. Must refer to one of the buttons configured via
    /// `buttons` / `add_button`.
    pub fn default_button(mut self, which: StandardButton) -> Self {
        self.default_button = Some(which);
        self
    }

    /// Mark which button activates on Escape (and scrim-click, when
    /// allowed). Must refer to one of the configured buttons.
    pub fn escape_button(mut self, which: StandardButton) -> Self {
        self.escape_button = Some(which);
        self
    }

    /// Attach a "Don't show again"-style checkbox below the body.
    /// Internally creates a `Signal<bool>` initialized to `false` and
    /// reports its state in [`MessageBoxResult::checkbox_checked`].
    /// For external observation, use
    /// [`MessageBox::show_again_checkbox_state`] instead.
    pub fn show_again_checkbox(mut self, label: impl Into<LocalizedString>) -> Self {
        self.show_again_label = Some(label.into());
        self
    }

    /// Like [`MessageBox::show_again_checkbox`], but with a
    /// caller-owned `Signal<bool>` so the checkbox state survives the
    /// dialog lifetime (useful for "remember my choice" persistence).
    pub fn show_again_checkbox_state(mut self, signal: Signal<bool>) -> Self {
        self.show_again_state = Some(signal);
        self
    }

    /// Where the title sits in the header's text column. Default
    /// [`HAlignment::Leading`]. `Center` matches a macOS alert; Windows and
    /// GNOME keep the title leading. `Leading` / `Trailing` follow the layout
    /// direction, so they mirror in right-to-left locales.
    pub fn title_alignment(mut self, alignment: HAlignment) -> Self {
        self.title_alignment = alignment;
        self
    }

    /// Where the button row sits along the bottom of the dialog. Default
    /// [`HAlignment::Trailing`]. `Center` matches a macOS alert; `Leading`
    /// packs the buttons at the start edge. `Leading` / `Trailing` follow the
    /// layout direction, so they mirror in right-to-left locales.
    pub fn button_alignment(mut self, alignment: HAlignment) -> Self {
        self.button_alignment = alignment;
        self
    }

    /// Register the result callback, invoked exactly once however the
    /// dialog closes — a button (by click, or by the Enter/Escape
    /// shortcut), a press outside, or a programmatic dismissal.
    pub fn on_result(mut self, f: impl Fn(MessageBoxResult, &mut EventContext) + 'static) -> Self {
        self.on_result = Some(Box::new(f));
        self
    }

    /// Present the MessageBox as a modal on top of `ctx`'s current
    /// tree. Consumes `self`; callers who need to present multiple
    /// dialogs with shared config should build a factory closure.
    pub fn present(mut self, ctx: &mut EventContext) {
        let title = self.title.clone();
        let close_behavior = if self.severity == MessageBoxSeverity::Critical {
            ModalCloseBehavior::EscapeKey
        } else {
            ModalCloseBehavior::EscapeOrClickOutside
        };

        // Report the answer however the dialog goes away, not only when a
        // button is pressed. Escape and a press outside both close the modal
        // through the overlay system, which never reached the button
        // resolution below — so a dismissed dialog told its caller nothing,
        // and a "Save changes?" prompt lost the user's answer outright. The
        // `fired` latch makes this a no-op when a button already answered.
        let slot: Rc<RefCell<Option<Rc<State>>>> = Rc::new(RefCell::new(None));
        self.state_slot = Some(slot.clone());
        let on_dismiss: teksilo_core::overlay::OverlayDismissCallback =
            Rc::new(move |reason, ctx: &mut EventContext| {
                let Some(state) = slot.borrow().clone() else {
                    return;
                };
                let Some(button) = state.resolve_escape_button() else {
                    return;
                };
                // `report`, not `fire`: the overlay is already being torn
                // down, and `dismiss_modal` here would be spent on whatever
                // modal is topmost when the deferred flag is read.
                state.report(button, MessageBoxDismissal::from(reason), ctx);
            });

        let dialog_title = self.title.clone();
        let mut inner = Some(self);
        ctx.present_modal(
            ModalRequest::deferred(move |tree| {
                let mb = inner
                    .take()
                    .expect("MessageBox present closure called twice");
                tree.add(ModalContainer::new(mb).title(dialog_title.clone()))
            })
            .presentation(ModalPresentation::Auto)
            .close_behavior(close_behavior)
            .title(title)
            .size(460, 140)
            .on_dismiss(on_dismiss),
        );
    }

    fn resolve_buttons(&mut self) -> Vec<MessageBoxButton> {
        let mut resolved = self
            .buttons_config
            .clone()
            .map(|b| b.into_buttons())
            .unwrap_or_default();
        resolved.extend(self.extra_buttons.iter().cloned());
        if resolved.is_empty() {
            resolved.push(StandardButton::Ok.into());
            if self.default_button.is_none() {
                self.default_button = Some(StandardButton::Ok);
            }
            if self.escape_button.is_none() {
                self.escape_button = Some(StandardButton::Ok);
            }
        }
        resolved
    }
}

impl Widget for MessageBox {
    fn build(&mut self, ctx: &mut BuildContext) -> Vec<WidgetId> {
        let theme = ctx.theme().clone();

        let checkbox_signal = self
            .show_again_state
            .clone()
            .unwrap_or_else(|| ctx.signal(false));
        let state = State::new(checkbox_signal.clone());
        *state.on_result.borrow_mut() = self.on_result.take();

        let buttons = self.resolve_buttons();
        *state.buttons.borrow_mut() = buttons.iter().map(|b| b.kind).collect();
        state.default_button.set(self.default_button);
        state.escape_button.set(self.escape_button);

        let mut header_text_stack = VStack::new().spacing(6.0);
        // The MessageBox itself already carries the title as its
        // AlertDialog name (see `Widget::accessibility` below).
        let title_text = TextWidget::new(self.title.clone())
            .style(theme.typography.body_bold.clone())
            .color(theme.colors.text_primary)
            .a11y_hidden();
        header_text_stack =
            if self.title_alignment == HAlignment::Leading {
                header_text_stack.child(title_text)
            } else {
                // Claim the column's width and place the title inside it; the
                // default (leading) keeps the bare title and the same tree as
                // before the knob existed.
                header_text_stack.child(Expand::horizontal().child(title_text).align_child(
                    Alignment {
                        horizontal: self.title_alignment,
                        vertical: VAlignment::Top,
                    },
                ))
            };
        if let Some(text) = self.text.clone() {
            header_text_stack = header_text_stack.child(
                TextWidget::new(text)
                    .style(theme.typography.body.clone())
                    .color(theme.colors.text_primary),
            );
        }
        if let Some(info) = self.informative_text.clone() {
            header_text_stack = header_text_stack.child(
                TextWidget::new(info)
                    .style(theme.typography.body.clone())
                    .color(theme.colors.text_secondary),
            );
        }

        let header: Box<dyn Widget> = if let Some(kind) = severity_icon_kind(self.severity) {
            // Wrap the text stack in `Expand::horizontal()` so HStack
            // distributes its width slack to the text column. Without
            // this the HStack measures the text stack with width=None
            // (single-line), which makes the body / informative text
            // overflow the dialog instead of wrapping.
            Box::new(
                HStack::new()
                    .spacing(16.0)
                    .alignment(VAlignment::Top)
                    .child(SeverityBadge::new(
                        kind,
                        severity_icon_size(&ctx.theme().input),
                    ))
                    .child(Expand::horizontal().child(header_text_stack)),
            )
        } else {
            Box::new(header_text_stack)
        };

        let detailed_child: Option<Box<dyn Widget>> = self.detailed_text.clone().map(|text| {
            let expanded = ctx.signal(false);
            let label: LocalizedString = teksilo_i18n::tr_widget!(messagebox_show_details());
            let body = TextWidget::new(text)
                .style(theme.typography.small.clone())
                .color(theme.colors.text_secondary);
            // Capped and scrollable rather than free-growing: see `DETAILS_MAX_HEIGHT`.
            // `preferred_height` caps the height only when the parent proposes an
            // unconstrained one — which a hugging dialog does — while leaving the width to
            // follow the content, so short details still size to themselves and never
            // acquire a scroll bar they do not need.
            let scroller = ScrollArea::new()
                .child(body)
                .preferred_height(DETAILS_MAX_HEIGHT);
            let accordion: Box<dyn Widget> =
                Box::new(Accordion::new(label, expanded).content(scroller));
            accordion
        });

        let checkbox_child: Option<Box<dyn Widget>> = self.show_again_label.clone().map(|label| {
            let cb: Box<dyn Widget> = Box::new(Checkbox::new(checkbox_signal.clone()).label(label));
            cb
        });

        // Slack goes before the buttons when they sit trailing or centred,
        // and after them when they sit leading or centred.
        let button_alignment = self.button_alignment;
        let mut footer = HStack::new().spacing(8.0);
        if button_alignment != HAlignment::Leading {
            footer = footer.child(Spacer::new());
        }
        state.button_ids.borrow_mut().clear();
        for button_cfg in &buttons {
            let kind = button_cfg.kind;
            let label = button_cfg.resolved_label();
            let variant = if Some(kind) == self.default_button {
                ButtonVariant::Filled
            } else {
                ButtonVariant::Plain
            };
            let state_for_btn = state.clone();
            let btn_id = ctx.add(
                Button::new(label)
                    .variant(variant)
                    .on_activate_fn(move |ctx| {
                        state_for_btn.fire(kind, MessageBoxDismissal::Button, ctx);
                    }),
            );
            if Some(kind) == self.default_button {
                self.default_button_id.set(Some(btn_id));
            }
            state.button_ids.borrow_mut().push((btn_id, kind));
            footer = footer.child(btn_id);
        }
        if button_alignment != HAlignment::Trailing {
            footer = footer.child(Spacer::new());
        }

        let mut stack = VStack::new().spacing(16.0);
        stack = stack.child(ctx.add_boxed(header));
        if let Some(det) = detailed_child {
            stack = stack.child(ctx.add_boxed(det));
        }
        if let Some(cb) = checkbox_child {
            stack = stack.child(ctx.add_boxed(cb));
        }
        // Push the footer to the bottom of the dialog by absorbing any
        // vertical slack with a Spacer (flex=1).
        stack = stack.child(ctx.add(Spacer::new()));
        let footer_id = ctx.add(footer);
        stack = stack.child(footer_id);

        // `Live::Off` on the root of the content. The box is an assertive
        // live region so that its *name*, the title, interrupts as it
        // opens, and `accesskit_consumer` hands a node's politeness down to
        // every descendant that sets none (node.rs:906-910). All three
        // adapters announce each named node entering the filtered tree with
        // an inherited politeness (atspi_common adapter.rs:71-77, windows
        // adapter.rs:255-263, macos event.rs:236-241), so once the dialog
        // panel stopped hiding the box, opening it announced the text, the
        // informative text and every button as well, each assertive, in
        // hash order, and each cutting off the one before: Orca 46.1 speaks
        // an announcement by interrupting the last (`speakMessage` in
        // `scripts/default.py` defaults to `interrupt=True`), so what was left
        // to hear was a button's name. The text still reaches a reader as the
        // box's description and by walking it. The root stays a
        // `GenericContainer`: the walker keeps it because it now says
        // something, and the adapters step through it to its children, which
        // inherit what it says.
        let root = ctx.add(
            stack
                .access_role(teksilo_core::accesskit::Role::GenericContainer)
                .access_live(teksilo_core::accesskit::Live::Off),
        );
        self.root_child_id = Some(root);

        {
            let state_enter = state.clone();
            ctx.register_action(
                Action::new(DEFAULT_INTENT_NAME).on_invoke(move |_intent, ctx| {
                    // The focused button wins, and only then the default.
                    //
                    // This shortcut is widget-scoped, and a scoped shortcut is
                    // matched before the focused widget is offered the key, so
                    // without this the default answered for a button the user
                    // had deliberately tabbed to: standing on Yes and pressing
                    // Enter in a `YesNo` box whose default is No said No, shut
                    // the dialog, and left the caller's `on_result` looking as
                    // though the user had declined. Every desktop toolkit puts
                    // the focused push button first here, and a confirmation
                    // whose safe answer is the default is exactly where the
                    // difference is destructive.
                    //
                    // `Button` already activates on Enter itself, so this is
                    // only about which of the two answers the key, never about
                    // making the button work.
                    let focused = ctx.focused().and_then(|id| state_enter.button_for(id));
                    if let Some(kind) = focused.or_else(|| state_enter.default_button.get()) {
                        state_enter.fire(kind, MessageBoxDismissal::Button, ctx);
                    }
                }),
            );
            ctx.register_shortcut(
                Shortcut::new(DEFAULT_INTENT_NAME)
                    .primary(KeyStroke::new(Key::Enter, Modifiers::NONE))
                    .build(),
            );
        }
        {
            let state_escape = state.clone();
            ctx.register_action(
                Action::new(ESCAPE_INTENT_NAME).on_invoke(move |_intent, ctx| {
                    if let Some(kind) = state_escape.resolve_escape_button() {
                        state_escape.fire(kind, MessageBoxDismissal::Escape, ctx);
                    } else {
                        ctx.dismiss_modal();
                    }
                }),
            );
            ctx.register_shortcut(
                Shortcut::new(ESCAPE_INTENT_NAME)
                    .primary(KeyStroke::new(Key::Escape, Modifiers::NONE))
                    .build(),
            );
        }

        if let Some(slot) = &self.state_slot {
            *slot.borrow_mut() = Some(state.clone());
        }
        self.state = Some(state);
        vec![root]
    }

    fn layout_response(
        &self,
        proposal: SizeProposal,
        ctx: &LayoutContext,
    ) -> teksilo_core::widget::LayoutResponse {
        // Enforce a 460×140 floor without clamping the forwarded
        // proposal: the overlay's intrinsic-measurement pass calls us
        // with (None, None), and a Spacer-bearing VStack child would
        // otherwise collapse to the proposal height. Letting the child
        // see the unmodified proposal lets it report its real natural
        // size — required so the overlay grows when the "Show details"
        // accordion expands.
        let child = self
            .root_child_id
            .and_then(|id| ctx.child_size(id, proposal))
            .unwrap_or_else(|| proposal.resolve(0.0, 0.0));
        Size::new(child.width.max(460.0), child.height.max(140.0)).into()
    }

    fn place_children(
        &self,
        bounds: Rect,
        _proposal: SizeProposal,
        children: &mut [WidgetPlacement],
        _ctx: &LayoutContext,
    ) {
        for child in children.iter_mut() {
            child.origin = bounds.origin();
            child.size = bounds.size();
        }
    }

    fn paint(&self, _bounds: Rect, _canvas: &mut teksilo_canvas::Canvas, _ctx: &PaintContext) {}

    fn accessibility(&self, builder: &mut AccessNodeBuilder) {
        builder.set_role(teksilo_core::accesskit::Role::AlertDialog);
        builder.set_name(self.title.clone());
        if let Some(description) = self.accessible_description() {
            builder.set_description(description);
        }
        builder.set_modal();
        builder.set_live(teksilo_core::accesskit::Live::Assertive);
        builder.add_action(teksilo_core::accesskit::Action::Focus);
    }

    fn accessible_title_hint(&self) -> Option<String> {
        Some(self.title.resolve_now())
    }

    fn initial_focus_hint(&self) -> Option<WidgetId> {
        self.default_button_id.get()
    }

    fn children(&self) -> Vec<WidgetId> {
        self.root_child_id.into_iter().collect()
    }
}

impl MessageBox {
    fn accessible_description(&self) -> Option<String> {
        match (
            self.text.as_ref().map(|t| t.resolve_now()),
            self.informative_text.as_ref().map(|i| i.resolve_now()),
        ) {
            (None, None) => None,
            (Some(t), None) => Some(t),
            (None, Some(i)) => Some(i),
            (Some(t), Some(i)) => Some(format!("{t}\n{i}")),
        }
    }
}

/// Extension trait on [`EventContext`] for ergonomic MessageBox
/// presentation. Mirrors `ctx.present_modal(...)` for the general
/// case.
pub trait EventContextMessageBoxExt {
    /// Present `mb` as a modal. Equivalent to `mb.present(self)`.
    fn present_message_box(&mut self, mb: MessageBox);
}

impl EventContextMessageBoxExt for EventContext<'_> {
    fn present_message_box(&mut self, mb: MessageBox) {
        mb.present(self);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use teksilo_core::ModalContent;
    use teksilo_core::event::WidgetEvent;
    use teksilo_core::widget_tree::WidgetTree;
    use teksilo_i18n::lit;

    /// Mirrors the focus resolution `teksilo_app::present_in_tree_modal_request`
    /// applies after the modal content subtree is built. Reproduced here
    /// because `teksilo-widgets` can't depend on `teksilo-app`.
    fn present_and_lay_out(tree: &mut WidgetTree, mb: MessageBox) -> WidgetId {
        use crate::button::Button as Btn;
        let mb_cell: Rc<RefCell<Option<MessageBox>>> = Rc::new(RefCell::new(Some(mb)));
        let mb_for_closure = mb_cell.clone();
        let trigger = tree.add(Btn::new(lit!("Open")).on_activate_fn(move |ctx| {
            if let Some(mb) = mb_for_closure.borrow_mut().take() {
                mb.present(ctx);
            }
        }));
        tree.layout(SizeProposal::exact(800.0, 600.0));
        tree.dispatch_event(WidgetEvent::AccessAction {
            action: teksilo_core::accesskit::Action::Click,
            target: Some(trigger),
            target_node: teksilo_core::accessibility::root_node_id(),
            data: None,
        });
        let request = tree.drain_pending_modal_requests().pop().unwrap().request;
        let content_id = match request.content {
            ModalContent::Deferred(builder) => builder(tree),
            ModalContent::ExistingWidget(_) => panic!("MessageBox must use deferred content"),
        };
        tree.layout(SizeProposal::exact(800.0, 600.0));
        let focus_target = request
            .focus_target
            .filter(|id| tree.is_active(*id) && tree.is_descendant_of(*id, content_id))
            .or_else(|| tree.widget_initial_focus_hint(content_id))
            .or_else(|| tree.first_focusable_descendant(content_id));
        if let Some(id) = focus_target {
            tree.focus(id);
        }
        content_id
    }

    /// The `MessageBox`, the title widget and the leftmost / rightmost button
    /// edges, all in the tree's own bounds space.
    struct Placement {
        message_box: Rect,
        title: Rect,
        buttons_left: f32,
        buttons_right: f32,
    }

    fn placement_of(tree: &WidgetTree, content: WidgetId) -> Placement {
        let panel = tree.children(content).first().copied().unwrap();
        let mb_id = tree.children(panel).first().copied().unwrap();
        let mut stack = vec![mb_id];
        let mut title_rect = None;
        let (mut left, mut right) = (f32::MAX, f32::MIN);
        while let Some(id) = stack.pop() {
            stack.extend(tree.children(id));
            let is = |name: &str| tree.widget_type_name(id).is_some_and(|t| t.ends_with(name));
            // The title is the topmost text in the box (`TextWidget` has no
            // `Debug` content to match on).
            if is("TextWidget") {
                let b = tree.bounds(id);
                if title_rect.is_none_or(|t: Rect| b.y < t.y) {
                    title_rect = Some(b);
                }
            }
            if is("Button") {
                let b = tree.bounds(id);
                left = left.min(b.x);
                right = right.max(b.x + b.width);
            }
        }
        Placement {
            message_box: tree.bounds(mb_id),
            title: title_rect.expect("title widget"),
            buttons_left: left,
            buttons_right: right,
        }
    }

    fn placement_with(
        title_alignment: Option<HAlignment>,
        button_alignment: Option<HAlignment>,
    ) -> Placement {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mut mb = MessageBox::plain(lit!("ZqTitle"))
            .text(lit!(
                "A body line that is long enough to make the column wide."
            ))
            .buttons(MessageBoxButtons::OkCancel);
        if let Some(a) = title_alignment {
            mb = mb.title_alignment(a);
        }
        if let Some(a) = button_alignment {
            mb = mb.button_alignment(a);
        }
        let content = present_and_lay_out(&mut tree, mb);
        placement_of(&tree, content)
    }

    #[test]
    fn default_alignment_is_leading_title_and_trailing_buttons() {
        let p = placement_with(None, None);
        let m = p.message_box;
        assert!(
            (p.title.x - m.x).abs() < 40.0,
            "title leads: {:?} in {m:?}",
            p.title
        );
        assert!(
            (m.x + m.width - p.buttons_right).abs() < 40.0,
            "buttons trail: right edge {} in {m:?}",
            p.buttons_right
        );
        assert!(p.buttons_left > m.x + m.width / 2.0 - 100.0 || m.width < 300.0);
    }

    #[test]
    fn centred_title_and_buttons_sit_in_the_middle() {
        let p = placement_with(Some(HAlignment::Center), Some(HAlignment::Center));
        let m = p.message_box;
        let mid = m.x + m.width / 2.0;
        let title_mid = p.title.x + p.title.width / 2.0;
        assert!(
            (title_mid - mid).abs() < 12.0,
            "title centre {title_mid} vs {mid}"
        );
        let buttons_mid = (p.buttons_left + p.buttons_right) / 2.0;
        assert!(
            (buttons_mid - mid).abs() < 12.0,
            "buttons centre {buttons_mid} vs {mid}"
        );
    }

    #[test]
    fn trailing_title_and_leading_buttons_swap_edges() {
        let p = placement_with(Some(HAlignment::Trailing), Some(HAlignment::Leading));
        let m = p.message_box;
        let default = placement_with(None, None);
        assert!(
            p.title.x > default.title.x + 20.0,
            "title moved to the trailing side"
        );
        assert!(
            p.buttons_left < default.buttons_left - 20.0,
            "buttons moved to the leading side"
        );
        assert!(
            p.buttons_left < m.x + 60.0,
            "buttons lead: {} in {m:?}",
            p.buttons_left
        );
    }

    #[test]
    fn present_queues_modal_request() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::information(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::Ok);
        let _content = present_and_lay_out(&mut tree, mb);
        assert!(tree.find_by_label("t").is_some());
    }

    #[test]
    fn critical_uses_escape_only_close_behavior() {
        use crate::button::Button as Btn;
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb_cell: Rc<RefCell<Option<MessageBox>>> = Rc::new(RefCell::new(Some(
            MessageBox::critical(lit!("Fatal"))
                .text(lit!("Boom"))
                .buttons(MessageBoxButtons::Ok),
        )));
        let mb_for_closure = mb_cell.clone();
        let trigger = tree.add(Btn::new(lit!("Open")).on_activate_fn(move |ctx| {
            if let Some(mb) = mb_for_closure.borrow_mut().take() {
                mb.present(ctx);
            }
        }));
        tree.layout(SizeProposal::exact(800.0, 600.0));
        tree.dispatch_event(WidgetEvent::AccessAction {
            action: teksilo_core::accesskit::Action::Click,
            target: Some(trigger),
            target_node: teksilo_core::accessibility::root_node_id(),
            data: None,
        });
        let request = tree.drain_pending_modal_requests().pop().unwrap().request;
        assert_eq!(request.close_behavior, ModalCloseBehavior::EscapeKey);
    }

    #[test]
    fn alert_dialog_role_exposed() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::warning(lit!("Title"))
            .text(lit!("Body"))
            .buttons(MessageBoxButtons::Ok);
        let content = present_and_lay_out(&mut tree, mb);
        // `content` is the `ModalContainer`; its child is now the
        // `DialogStyle` panel frame, and the `MessageBox` sits one
        // level below that.
        let panel = tree.children(content).first().copied().unwrap();
        let mb_id = tree.children(panel).first().copied().unwrap();
        let info = tree.accessibility_node(mb_id);
        assert_eq!(info.role(), teksilo_core::accesskit::Role::AlertDialog);
        assert_eq!(info.name(), Some("Title"));
    }

    /// Only the box itself is live. Its content inherited the box's
    /// assertive setting through `accesskit_consumer`'s `live()`, so every
    /// button and line of text was an announcement of its own.
    #[test]
    fn nothing_inside_the_box_is_live_on_its_own() {
        use teksilo_core::accesskit::{Live, Role};
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::warning(lit!("Supprimer « Vacances » ?"))
            .text(lit!("Cet évènement sera retiré de votre liste."))
            .buttons(MessageBoxButtons::YesNo)
            .default_button(StandardButton::No);
        let _content = present_and_lay_out(&mut tree, mb);
        let update = tree.sync_accessibility();

        let consumer = accesskit_consumer::Tree::new(update, true);
        let state = consumer.state();
        let mut stack = vec![state.root()];
        let mut the_box = None;
        let mut inside = Vec::new();
        while let Some(node) = stack.pop() {
            if node.role() == Role::AlertDialog {
                the_box = Some((node.label(), node.live()));
                let mut below: Vec<_> = node.children().collect();
                while let Some(child) = below.pop() {
                    inside.push((child.role(), child.live()));
                    below.extend(child.children());
                }
            }
            stack.extend(node.children());
        }
        assert_eq!(
            the_box,
            Some((
                Some("Supprimer « Vacances » ?".to_string()),
                Live::Assertive
            )),
            "the box stays an assertive live region named by its question"
        );
        assert!(
            inside.iter().any(|(role, _)| *role == Role::Button),
            "the walk must reach the buttons for this to say anything"
        );
        let live_inside: Vec<_> = inside
            .iter()
            .filter(|(_, live)| *live != Live::Off)
            .collect();
        assert!(
            live_inside.is_empty(),
            "live inside the box: {live_inside:?}"
        );
    }

    /// What opening the box used to announce: the focused button, as an
    /// assertive live region of its own, which interrupts. It is announced as
    /// the focus now, the way any focused control is, and not a second time.
    /// What the box announces is its question, once: a ring that heard
    /// nothing at all would pass the first half of this.
    #[test]
    fn opening_the_box_does_not_announce_its_buttons() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        tree.layout(SizeProposal::exact(800.0, 600.0));
        let _ = tree.sync_accessibility();
        let seen = tree.announcements_since(0).last().map_or(0, |a| a.seq);
        let mb = MessageBox::warning(lit!("Supprimer « Vacances » ?"))
            .text(lit!("Cet évènement sera retiré de votre liste."))
            .buttons(MessageBoxButtons::YesNo)
            .default_button(StandardButton::No);
        let _content = present_and_lay_out(&mut tree, mb);
        let _ = tree.sync_accessibility();
        let heard: Vec<String> = tree
            .announcements_since(seen)
            .into_iter()
            .map(|a| a.text)
            .collect();
        let yes = StandardButton::Yes.default_label().resolve_now();
        let no = StandardButton::No.default_label().resolve_now();
        assert!(
            !heard
                .iter()
                .any(|t| *t == yes || *t == no || t.starts_with("Cet évènement")),
            "heard {heard:?}"
        );
        assert_eq!(
            heard,
            ["Supprimer « Vacances » ?"],
            "the question, once, and nothing else"
        );
    }

    #[test]
    fn title_label_is_hidden_but_body_label_survives() {
        // The MessageBox's own AlertDialog node already carries the title
        // as its name (set on the node, not drawn through `labelled_by`, so
        // that a new title is a change of the node the adapters announce),
        // so the embedded title Label must not
        // reach the AT tree as a second, duplicate-named stop. The body
        // text, which is not a duplicate, must still be present.
        use teksilo_core::accessibility::widget_id_to_node_id;
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::warning(lit!("Title"))
            .text(lit!("Body"))
            .buttons(MessageBoxButtons::Ok);
        let content = present_and_lay_out(&mut tree, mb);
        let panel = tree.children(content).first().copied().unwrap();
        let mb_id = tree.children(panel).first().copied().unwrap();

        let update = tree.sync_accessibility();

        let mb_node_id = widget_id_to_node_id(mb_id);
        let mb_node = update
            .nodes
            .iter()
            .find(|(nid, _)| *nid == mb_node_id)
            .map(|(_, node)| node)
            .expect("MessageBox node");
        assert_eq!(mb_node.role(), teksilo_core::accesskit::Role::AlertDialog);
        assert_eq!(
            mb_node.label(),
            Some("Title"),
            "hiding the title label must not take the dialog's own name away with it",
        );

        assert!(
            !update.nodes.iter().any(|(_, node)| node.role()
                == teksilo_core::accesskit::Role::Label
                && teksilo_core::accessibility::announced_text(node) == Some("Title")),
            "the title Label must not survive as a duplicate-named node",
        );

        assert!(
            update.nodes.iter().any(|(_, node)| node.role()
                == teksilo_core::accesskit::Role::Label
                && teksilo_core::accessibility::announced_text(node) == Some("Body")),
            "the body label is not a name duplicate and must stay visible",
        );
    }

    #[test]
    fn ok_button_fires_result_with_correct_kind() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::information(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::Ok)
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        let ok_id = tree
            .find_by_label(&StandardButton::Ok.default_label().resolve_now())
            .unwrap();
        tree.dispatch_event(WidgetEvent::AccessAction {
            action: teksilo_core::accesskit::Action::Click,
            target: Some(ok_id),
            target_node: teksilo_core::accessibility::root_node_id(),
            data: None,
        });
        let result = captured.borrow().expect("result must be captured");
        assert_eq!(result.button, StandardButton::Ok);
        assert!(!result.checkbox_checked);
        assert_eq!(result.dismissal, MessageBoxDismissal::Button);
    }

    #[test]
    fn default_button_is_focused_on_open() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::YesNoCancel)
            .default_button(StandardButton::No);
        let _content = present_and_lay_out(&mut tree, mb);
        let no_id = tree
            .find_by_label(&StandardButton::No.default_label().resolve_now())
            .unwrap();
        assert_eq!(tree.focused(), Some(no_id));
    }

    /// The reason this preset default exists. A Yes/No box is a confirmation,
    /// a confirmation usually precedes something destructive, and Enter is what
    /// a keyboard user presses on a dialog they have not finished reading.
    ///
    /// Focus placement is the whole contract: `Node::keyboard_shortcut` appears
    /// in none of the three AccessKit adapters, so no platform announces which
    /// button is the default. A screen-reader user finds out by triggering it.
    #[test]
    fn a_yes_no_box_defaults_to_no_so_enter_cannot_destroy() {
        for buttons in [MessageBoxButtons::YesNo, MessageBoxButtons::YesNoCancel] {
            let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
            let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
            let captured_for_handler = captured.clone();
            let mb = MessageBox::question(lit!("t"))
                .text(lit!("x"))
                .buttons(buttons.clone())
                .on_result(move |r, _ctx| {
                    *captured_for_handler.borrow_mut() = Some(r);
                });
            let _content = present_and_lay_out(&mut tree, mb);

            let no_id = tree
                .find_by_label(&StandardButton::No.default_label().resolve_now())
                .unwrap();
            assert_eq!(
                tree.focused(),
                Some(no_id),
                "{buttons:?} must open with No focused"
            );

            tree.press_key(Key::Enter, Modifiers::NONE);
            let result = captured.borrow().expect("result must be captured");
            assert_eq!(
                result.button,
                StandardButton::No,
                "{buttons:?}: Enter on an unread confirmation must not answer Yes"
            );
        }
    }

    /// Escape and Enter are different buttons for `YesNoCancel`, and both
    /// matter: Escape means "I did not mean to be in this dialog", which is
    /// Cancel, while Enter answers the question that was asked.
    #[test]
    fn yes_no_cancel_keeps_cancel_as_the_escape_button() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::YesNoCancel)
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        tree.press_key(Key::Escape, Modifiers::NONE);
        let result = captured.borrow().expect("result must be captured");
        assert_eq!(result.button, StandardButton::Cancel);
        assert_eq!(result.dismissal, MessageBoxDismissal::Escape);
    }

    /// The override still works, and is how a box that asks something safe
    /// gets Yes back.
    #[test]
    fn default_button_overrides_the_preset() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::YesNo)
            .default_button(StandardButton::Yes);
        let _content = present_and_lay_out(&mut tree, mb);
        let yes_id = tree
            .find_by_label(&StandardButton::Yes.default_label().resolve_now())
            .unwrap();
        assert_eq!(tree.focused(), Some(yes_id));
    }

    /// Enter answers for the button the user is standing on.
    ///
    /// This asserted the opposite until 0.9.3, and the opposite is what every
    /// caller of a `YesNo` box was living with: the shortcut that carries
    /// Enter is widget-scoped, so it is matched before the focused widget is
    /// offered the key, and the default answered for a button the user had
    /// deliberately tabbed to. In a confirmation whose safe answer is the
    /// default, that turns a deliberate Yes into a silent No.
    #[test]
    fn enter_fires_the_focused_button_rather_than_the_default() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::OkCancel)
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        let cancel_id = tree
            .find_by_label(&StandardButton::Cancel.default_label().resolve_now())
            .unwrap();
        tree.focus(cancel_id);
        tree.press_key(Key::Enter, Modifiers::NONE);
        let result = captured.borrow().expect("result must be captured");
        assert_eq!(
            result.button,
            StandardButton::Cancel,
            "Enter must answer for the focused button, not for the default"
        );
        assert_eq!(result.dismissal, MessageBoxDismissal::Button);
    }

    /// And the default still answers when the focus is not on a button.
    ///
    /// The "show again" checkbox is the case that exists in a real box: it
    /// takes focus, and it handles Space rather than Enter, so Enter reaches
    /// the shortcut with the focus somewhere that is not one of the answers.
    #[test]
    fn enter_still_fires_the_default_when_the_focus_is_not_a_button() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::OkCancel)
            .show_again_checkbox(lit!("Ne plus demander"))
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        let checkbox_id = tree.find_by_label("Ne plus demander").unwrap();
        tree.focus(checkbox_id);
        tree.press_key(Key::Enter, Modifiers::NONE);
        let result = captured.borrow().expect("result must be captured");
        assert_eq!(result.button, StandardButton::Ok);
        assert_eq!(result.dismissal, MessageBoxDismissal::Button);
    }

    #[test]
    fn escape_fires_escape_button_and_marks_dismissed() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::question(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::YesNoCancel)
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        tree.press_key(Key::Escape, Modifiers::NONE);
        let result = captured.borrow().expect("result must be captured");
        assert_eq!(result.button, StandardButton::Cancel);
        assert_eq!(result.dismissal, MessageBoxDismissal::Escape);
    }

    #[test]
    fn checkbox_state_reported_in_result() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let shared_state = Signal::new(false);
        let captured: Rc<RefCell<Option<MessageBoxResult>>> = Rc::new(RefCell::new(None));
        let captured_for_handler = captured.clone();
        let mb = MessageBox::information(lit!("t"))
            .text(lit!("x"))
            .buttons(MessageBoxButtons::Ok)
            .show_again_checkbox_state(shared_state.clone())
            .show_again_checkbox(lit!("Don't show again"))
            .on_result(move |r, _ctx| {
                *captured_for_handler.borrow_mut() = Some(r);
            });
        let _content = present_and_lay_out(&mut tree, mb);
        shared_state.set(true);
        let ok_id = tree
            .find_by_label(&StandardButton::Ok.default_label().resolve_now())
            .unwrap();
        tree.dispatch_event(WidgetEvent::AccessAction {
            action: teksilo_core::accesskit::Action::Click,
            target: Some(ok_id),
            target_node: teksilo_core::accessibility::root_node_id(),
            data: None,
        });
        assert!(captured.borrow().unwrap().checkbox_checked);
    }

    #[test]
    fn the_presenting_container_is_no_second_dialog() {
        // This test used to ask for the container to be a `Role::Dialog`
        // named by the box's title, which was the one dialog a reader met
        // while the panel between them hid the box. With the box reachable
        // that is a second dialog of the same name around its
        // `AlertDialog`, and Orca speaks each dialog a focus change enters,
        // so the title was heard twice. The box is the dialog; the
        // container publishes a bare `GenericContainer`, which every
        // adapter drops.
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let mb = MessageBox::information(lit!("Title propagation test"))
            .text(lit!("Body"))
            .buttons(MessageBoxButtons::Ok);
        let content = present_and_lay_out(&mut tree, mb);
        let container = tree.accessibility_node(content);
        assert_eq!(
            container.role(),
            teksilo_core::accesskit::Role::GenericContainer
        );
        assert_eq!(container.name(), None);
        let panel = tree.children(content).first().copied().unwrap();
        let mb_id = tree.children(panel).first().copied().unwrap();
        let info = tree.accessibility_node(mb_id);
        assert_eq!(info.role(), teksilo_core::accesskit::Role::AlertDialog);
        assert_eq!(info.name(), Some("Title propagation test"));
    }

    #[test]
    fn standard_button_roles_classify_correctly() {
        assert_eq!(StandardButton::Ok.role(), ButtonRole::Accept);
        assert_eq!(StandardButton::Yes.role(), ButtonRole::Accept);
        assert_eq!(StandardButton::Save.role(), ButtonRole::Accept);
        assert_eq!(StandardButton::Cancel.role(), ButtonRole::Reject);
        assert_eq!(StandardButton::No.role(), ButtonRole::Reject);
        assert_eq!(StandardButton::Abort.role(), ButtonRole::Reject);
        assert_eq!(StandardButton::Discard.role(), ButtonRole::Destructive);
        assert_eq!(StandardButton::Help.role(), ButtonRole::Action);
        assert_eq!(StandardButton::Ignore.role(), ButtonRole::Action);
    }

    /// A long `detailed_text` expands, stays reachable, and lays out without blowing up.
    ///
    /// The pane is where callers put the things with no length bound — a stack trace, an OS
    /// error dump, a list of every affected row — and it used to be a bare `TextWidget` in
    /// the accordion, so expanding it grew the dialog until the button row went off the
    /// bottom of the screen. It is capped and scrollable now (`DETAILS_MAX_HEIGHT`).
    ///
    /// This pins the reachable half: a hundred lines of detail still build, expand and
    /// re-lay out with the buttons intact. The *height* cap itself is not asserted here —
    /// `WidgetTree` exposes no laid-out geometry to widget tests, so there is nothing to
    /// measure against; that half is the `ScrollArea::preferred_height` contract, which
    /// `scroll_area` owns and tests.
    #[test]
    fn a_long_details_pane_expands_and_keeps_the_dialog_intact() {
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let long: String = (1..=100)
            .map(|i| format!("line {i} of a very long detail dump\n"))
            .collect();
        let mb = MessageBox::critical(lit!("Could not open file"))
            .text(lit!("It went wrong."))
            .detailed_text(lit!(long))
            .buttons(MessageBoxButtons::Ok);
        let _content = present_and_lay_out(&mut tree, mb);

        let toggle = tree
            .find_by_label(&teksilo_i18n::tr_widget!(messagebox_show_details()).resolve_now())
            .expect("the Show details toggle");
        tree.dispatch_event(WidgetEvent::AccessAction {
            action: teksilo_core::accesskit::Action::Click,
            target: Some(toggle),
            target_node: teksilo_core::accessibility::root_node_id(),
            data: None,
        });
        tree.layout(SizeProposal::exact(800.0, 600.0));

        // The dialog is still whole: its title and its button both survived the expansion.
        assert!(tree.find_by_label("Could not open file").is_some());
        assert!(
            tree.find_by_label(&StandardButton::Ok.default_label().resolve_now())
                .is_some(),
            "the button row must survive an expanded details pane"
        );
    }

    #[test]
    fn escape_resolution_prefers_explicit_escape_button() {
        let state = State::new(Signal::new(false));
        *state.buttons.borrow_mut() = vec![StandardButton::Save, StandardButton::Discard];
        state.escape_button.set(Some(StandardButton::Discard));
        assert_eq!(state.resolve_escape_button(), Some(StandardButton::Discard));
    }

    #[test]
    fn escape_resolution_falls_back_to_first_reject() {
        let state = State::new(Signal::new(false));
        *state.buttons.borrow_mut() = vec![
            StandardButton::Retry,
            StandardButton::Ignore,
            StandardButton::Abort,
        ];
        state.escape_button.set(None);
        assert_eq!(state.resolve_escape_button(), Some(StandardButton::Abort));
    }

    #[test]
    fn escape_resolution_falls_back_to_last_when_no_reject() {
        let state = State::new(Signal::new(false));
        *state.buttons.borrow_mut() = vec![StandardButton::Ok, StandardButton::Help];
        state.escape_button.set(None);
        assert_eq!(state.resolve_escape_button(), Some(StandardButton::Help));
    }
}