Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

180 KB
Raw Blame
//! The SolidCraft egui front end.
//!
//! A thin shell over [`solidcraft_engine::Session`]: panels read engine state and act through
//! commands ([`SolveApp::run`]). Nothing here owns design data. The layout follows the familiar
//! parametric-CAD desktop: application bar, a toolbar of workspace tabs and panels, the browser
//! on the left, the 3D viewport with an axis view and navigation bar, the command dialog on the
//! right of the viewport, the command palette and a bottom or left-sidebar feature timeline.
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
use crate::ui_kit::{Container, Surface};

pub mod access;
pub mod agent_chat;
pub mod agent_cursor;
pub mod ai_connect;
pub mod bidi;
pub mod blur;
pub mod bom_panel;
pub mod browser;
pub mod browser_canvas;
pub mod browser_prompts;
pub mod canvas;
pub mod cli_link;
#[cfg(test)]
mod colour_tokens_tests;
#[cfg(test)]
mod colour_vision_tests;
pub mod command_help;
pub mod context_menu;
pub mod control;
pub mod control_job;
pub mod crash_ui;
pub mod deferred;
pub mod delete;
pub mod design_properties;
pub mod dialog_column;
mod dialog_descriptor;
pub mod dialogs;
pub mod dialogs_appearance;
pub mod dialogs_assembly;
pub mod dialogs_coupling;
pub mod dialogs_frame;
mod dialogs_hole;
pub mod dialogs_insert_drawing;
pub mod dialogs_library;
pub mod dialogs_motion;
pub mod dialogs_move;
pub mod dialogs_part_size;
pub mod dialogs_parts;
pub mod dialogs_plastic;
pub mod dialogs_save_mesh;
pub mod dialogs_sheet;
pub mod dialogs_surface;
pub mod dialogs_sweep;
mod dialogs_thread;
pub mod dialogs_view_dxf;
pub mod dim_view;
#[cfg(test)]
mod dimension_create_ui_tests;
pub mod documents;
pub mod drag_extrude;
pub mod drag_snap;
pub mod easyprint_ui;
pub mod edit_clipboard;
pub mod edit_in_place;
mod feature_edit;
#[cfg(test)]
mod font_literals_tests;
pub mod fonts;
pub mod frame;
pub mod frame_rate;
pub mod gizmo;
pub mod gpu;
pub mod help;
mod history_folds;
pub(crate) mod history_rows;
#[cfg(test)]
mod hole_direction_ui_tests;
pub(crate) mod hole_folder;
pub(crate) mod hole_place;
#[cfg(test)]
mod hole_place_ui_tests;
#[cfg(test)]
mod hole_placement_ui_tests;
pub mod hole_presets;
pub(crate) mod hole_refs;
#[cfg(test)]
mod hole_refs_ui_tests;
pub mod home;
pub mod i18n;
#[cfg(test)]
mod i18n_menu_tests;
#[cfg(test)]
mod i18n_painted_tests;
#[cfg(test)]
mod i18n_ui_tests;
pub mod icon_svg;
pub mod icons;
pub mod inference;
pub mod insert_handles;
pub mod install;
pub mod issue_report;
pub mod joint_drag;
pub(crate) mod joint_handles;
pub mod keymap;
mod length_input;
mod linked_source;
#[cfg(test)]
mod loft_rails_dialog_tests;
#[cfg(test)]
mod look_at_tests;
#[cfg(test)]
mod manage_dialogs_tests;
mod material_card_review;
mod material_editor;

#[cfg(test)]
mod measurement_ui_tests;
#[cfg(test)]
mod menu_tests;
pub(crate) mod mesh_lod;
pub mod mesh_units;
pub mod messages;
pub(crate) mod motion;
pub mod occurrence_drag;
#[cfg(test)]
mod pattern_arrow_tests;
#[cfg(test)]
mod prompt_cards_tests;
#[cfg(test)]
mod scale_tests;
#[cfg(test)]
mod surface_clamp_tests;
#[cfg(test)]
mod surface_errors_tests;
#[cfg(test)]
mod timeline_dependents_tests;
#[cfg(test)]
mod timeline_marks_tests;
#[cfg(test)]
mod status_tests {
    #[test]
    fn the_status_bar_names_commands_by_label() {
        assert_eq!(super::command_label("solid.fillet"), "Fillet");
        assert_eq!(
            super::friendly_error("solid.shell", "invalid parameters for `solid.shell`: offset: must be positive"),
            "Shell: offset: must be positive"
        );
        assert_eq!(super::friendly_error("edit.undo", "nothing to undo"), "Undo: nothing to undo");
        {
            // The label follows the interface language; the engine's words stay English.
            let _polish = crate::i18n::scope("pl");
            assert_eq!(super::friendly_error("edit.undo", "nothing to undo"), "Cofnij: nothing to undo");
            assert_eq!(
                super::friendly_error("sketch.dimension", "invalid parameters for `sketch.dimension`: value: `mm` is a unit name"),
                "Wymiar szkicu: value: `mm` is a unit name"
            );
        }
        assert_eq!(super::friendly_error("edit.undo", "nothing to undo"), "Undo: nothing to undo");
        let mut app = super::SolveApp::new(solidcraft_engine::Session::default(), Default::default());
        app.run("solid.box", serde_json::json!({"length": 5, "width": 5, "height": 5})).unwrap();
        assert_eq!(app.session.log.last().map(String::as_str), Some("Box done"));
        let _ = app.run("edit.redo", serde_json::json!({}));
        assert!(app.session.log.last().is_some_and(|l| l.starts_with("Redo: ") && !l.contains("edit.redo")), "{:?}", app.session.log.last());
    }
}
#[cfg(test)]
mod apply_off_thread_tests;
mod expression_complete;
#[cfg(test)]
mod extrude_auto_to_object_tests;
#[cfg(test)]
mod extrude_edit_tests;
mod extrude_face_snap;
mod extrude_preview;
mod file_load;
mod file_picker;
pub(crate) mod frame_watch;
#[cfg(test)]
mod history_off_thread_tests;
mod move_preview;
pub use file_picker::FilePickerFuture;
#[cfg(test)]
mod blend_arrow_tests;
#[cfg(test)]
mod blend_dialog_tests;
#[cfg(test)]
mod boundary_dialog_tests;
pub(crate) mod display_lod;
#[cfg(test)]
mod file_load_ui_tests;
#[cfg(test)]
mod fillet_spline_handle_tests;
pub mod mouse_gesture;
pub(crate) mod navigation;
pub mod navigation_bar;
mod navigation_bar_view;
pub use navigation::WebWheelGestures;
pub mod network_prompt;
pub mod op_auto;
pub mod open_elsewhere;
pub(crate) mod open_meshing;
pub mod panel_runtime;
pub mod params_dialog;
pub mod personal_sheet_rules;
pub(crate) mod pick_index;
pub(crate) mod place_gizmo;
pub(crate) mod plugins;
pub mod point_clouds;
pub mod prefs;
pub mod prefs_notice;
mod prefs_search;
#[cfg(test)]
mod preselect_tests;
pub mod preview;
#[cfg(test)]
mod preview_placement_tests;
mod primitive_placement;
#[cfg(test)]
mod primitive_units_tests;
mod print_face_ui;
pub(crate) mod quick_measure;
#[cfg(test)]
mod quick_measure_tests;
pub(crate) mod recent_colors;
pub mod recovery_ui;
pub mod ref_images;
pub(crate) mod refused_part;
mod render_ui;
pub mod render_workspace;
pub mod resume_ui;
#[cfg(test)]
mod revolve_edit_tests;
#[cfg(test)]
mod revolve_manipulator_tests;
#[cfg(test)]
mod round_pick_tests;
mod rule_editor;
#[cfg(test)]
mod rule_editor_tests;
pub mod save_job;
pub mod scenario;
pub(crate) mod scene_palette;
pub mod select_other;
pub mod selection;
pub mod semantic_content;
pub mod settings_profiles;
#[cfg(test)]
mod settings_profiles_tests;
pub mod shell;
#[cfg(test)]
mod shell_face_sketch_ui_tests;
pub mod shortcut_box;
pub mod sketch3d;
#[cfg(test)]
mod sketch3d_frame_ui_tests;
pub(crate) mod sketch_attachment_ui;
#[cfg(test)]
mod sketch_attachment_ui_tests;
mod sketch_construction;
pub mod sketch_dims;
pub(crate) mod sketch_display;
#[cfg(test)]
mod sketch_display_ui_tests;
#[cfg(test)]
mod sketch_drag_ui_tests;
#[cfg(test)]
mod sketch_edit_tests;
mod sketch_families;
#[cfg(test)]
mod sketch_guidance_ui_tests;
pub(crate) mod sketch_line_arc;
pub mod sketch_modify_ui;
#[cfg(test)]
mod sketch_modify_ui_tests;
#[cfg(test)]
mod sketch_moving_click_tests;
pub mod sketch_palette;
mod sketch_pattern_tree;
pub mod sketch_report;
#[cfg(test)]
mod sketch_side_ui_tests;
mod sketch_state;
pub(crate) mod sketch_text;
mod sketch_text_handles;
mod sketch_text_move;
pub mod sketch_tools;
mod sketch_transform_ui;
pub mod smart_extrude;
#[cfg(test)]
mod smart_extrude_ui_tests;
pub mod space_mouse;
pub mod space_mouse_calibration;
pub mod space_mouse_model;
pub mod space_mouse_offer;
pub mod stand_up;
mod status_bar;
#[cfg(test)]
mod sweep_dialog_tests;
pub(crate) mod test_boat;
pub mod theme;
pub mod theme_files;
mod theme_options;
#[cfg(test)]
mod thin_extrude_tests;
pub mod timeline;
mod timeline_fold;
mod timeline_folders;
pub mod timeline_left;
mod timeline_scope;
pub mod titlebar;
pub mod tool_cursor;
pub mod tool_modifiers;
pub mod toolbar;
pub mod toolbar_custom;
pub mod tools;
pub mod ui_kit;
#[cfg(test)]
mod ui_kit_guard_tests;
pub mod update;
mod value_step;
pub(crate) mod view_angles;
mod view_confirm;
pub mod view_gizmo;
pub mod view_pick;
pub mod viewport;
mod viewport_details;
mod viewport_layout;
mod viewport_status;
mod viewport_status_fixture;
pub mod workspace;

use std::sync::mpsc::Receiver;

use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use solidcraft_engine::Session;
use solidcraft_engine::render::{Camera, CameraAnim, StandardView};

pub use control::{ControlRequest, ControlResponse};

/// How close (radians) the camera must be to a standard axis view for the #2682 mode
/// (`auto_ortho_faces`) to snap the projection to orthographic. One degree: exact axis views
/// and Shift-snapped orbits land inside it, free orbiting does not linger in it.
pub const ORTHO_FACE_TOLERANCE: f64 = 1.0_f64.to_radians();

/// UI state that automation can read and set (`ui.set`).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct UiState {
    /// Effective shell mode; automation can override the saved preference for this session.
    pub layout: shell::LayoutMode,
    /// Ribbon tab; SHEET METAL and the contextual SKETCH join the seven design tabs.
    pub tab: String,
    /// The toolbar tab a sketch was started from; finishing the sketch goes back to it (#3250).
    /// Not saved: it only lives while a sketch is open.
    #[serde(skip)]
    pub sketch_return_tab: Option<String>,
    /// The folded ribbon's panels are open over the view (`ribbon_tabs_only`, #10112). Not saved:
    /// a tab click opens them, and a command starting or the pointer leaving closes them.
    #[serde(skip)]
    pub ribbon_open: bool,
    /// Last contextual body/sketch, only used to select on entry.
    #[serde(skip)]
    pub ribbon_context: Option<String>,
    pub show_browser: bool,
    pub show_timeline: bool,
    pub show_grid: bool,
    pub show_navigation_bar: bool,
    pub perspective: bool,
    /// Perspective while orbiting, orthographic when the camera faces a standard axis view
    /// (#2682). Off by default; when on it decides the projection instead of `perspective`.
    pub auto_ortho_faces: bool,
    /// View angles card locks (#4581): a locked angle stays put while orbiting, turning with the
    /// arrow keys or using a 3D mouse, and its field and zero button in the card go inert.
    pub view_angles_lock_yaw: bool,
    pub view_angles_lock_pitch: bool,
    pub view_angles_lock_roll: bool,
    pub palette_open: bool,
    /// Dark theme (the default); a preference kept between runs.
    pub dark: bool,
    /// Selection filter: kinds a click doesn't pick (`vertices`, `edges`, `faces`, `sketch`).
    pub pick_off: Vec<String>,
    /// A click on a face picks its whole body.
    pub pick_bodies: bool,
    /// A face picks its exact component occurrence in Design and Render.
    pub pick_components: bool,
    /// The selection shape (#4376): a drag in the view draws a freehand lasso that takes what is
    /// wholly inside it, instead of the window/crossing rectangle. Off by default.
    pub lasso_select: bool,
    /// 0: shaded with edges, 1: shaded, 2: wireframe, 3: shaded with hidden edges.
    pub visual_style: u8,
    /// A soft shadow on the ground under the model (seen from above).
    pub ground_shadow: bool,
    /// The world's up axis (Z or Y; #3): the camera, axis view, home view and ground follow it.
    pub up_axis: solidcraft_engine::render::UpAxis,
    /// The agent cursor: shown, speed, follow camera (#35).
    pub agent_cursor: agent_cursor::Settings,
    /// The running tool's icon rides beside the pointer in the viewport (View settings; off by
    /// default).
    pub tool_cursor: bool,
    /// The colours picked last in any colour picker, newest first (#9234); kept between runs.
    pub recent_colors: Vec<[u8; 3]>,
}

impl UiState {
    fn pick_mode(&self) -> &'static str {
        if self.pick_components {
            "component"
        } else if self.pick_bodies {
            "body"
        } else {
            "face"
        }
    }
}

impl Default for UiState {
    fn default() -> Self {
        UiState {
            layout: Default::default(),
            tab: "MODEL".into(),
            ribbon_context: None,
            sketch_return_tab: None,
            ribbon_open: false,
            show_browser: true,
            show_timeline: true,
            show_grid: true,
            show_navigation_bar: true,
            perspective: false,
            auto_ortho_faces: false,
            view_angles_lock_yaw: false,
            view_angles_lock_pitch: false,
            view_angles_lock_roll: false,
            palette_open: false,
            dark: true,
            pick_off: Vec::new(),
            pick_bodies: false,
            pick_components: false,
            lasso_select: false,
            visual_style: 0,
            ground_shadow: true,
            up_axis: Default::default(),
            agent_cursor: Default::default(),
            tool_cursor: false,
            recent_colors: Vec::new(),
        }
    }
}

/// Host services injected by the app so this crate stays portable.
#[derive(Default)]
pub struct Services {
    /// Ask for a file to open. The extensions are the file type the command reads, offered as
    /// the picker's first filter (`&[]`: designs, CAD files and meshes, #1801).
    pub pick_open: Option<Box<dyn Fn(&[&str]) -> FilePickerFuture>>,
    pub pick_save: Option<Box<dyn Fn(&str, &[&str]) -> FilePickerFuture>>,
    /// Open a dialog for one file of a kind (its name, its extensions): on macOS a dialog allows
    /// only the types it names, so the agent chat's files need a dialog of their own. `None`: the
    /// Open dialog.
    pub pick_file: Option<Box<dyn Fn(&str, &[&str]) -> FilePickerFuture>>,
    /// Open a dialog asking for a program (a slicer); `None` when the host has no such dialog.
    pub pick_program: Option<Box<dyn Fn() -> FilePickerFuture>>,
    pub show_in_folder: Option<Box<dyn Fn(&str)>>,
    /// Where the host reads the anti-aliasing preference at start (a small JSON file).
    pub graphics_path: Option<String>,
    /// Linux: the window system this run uses, `wayland` or `x11` (Preferences shows it, #3083).
    pub window_system: Option<&'static str>,
    /// The desktop's dark (`Some(true)`) or light preference as the host reads it, for Theme:
    /// System where the window toolkit does not report it (Linux desktops, #7944). Called every
    /// frame, so it only reads a value kept up to date elsewhere. None, or `None` from it: the
    /// window toolkit's theme.
    pub desktop_dark: Option<Box<dyn Fn() -> Option<bool>>>,
    /// Lazy background observation; `needed` arms polling, the return is cached only.
    pub reduce_transparency: Option<Box<dyn Fn(bool) -> Option<bool>>>,
    /// Adapter names and descriptive labels from the desktop renderer's chosen backends.
    pub graphics_adapters: Vec<(String, String)>,
    /// HTTPS GET for the update check (`update`); None: never check (browser, tests).
    pub http_get: Option<update::HttpGet>,
    /// HTTPS download to a file, with progress, for one-click updates (`update::install`).
    pub http_download: Option<update::install::HttpDownload>,
    /// The browser's offer to install the web app (`install`); None: no Install button (desktop).
    pub install_app: Option<install::InstallApp>,
    /// Hand a design's bytes to the user as a downloaded file (name, bytes); the browser build's
    /// File > Download design. None: the host saves real files, so there is nothing to offer.
    pub download_design: Option<Box<dyn Fn(&str, &[u8]) -> Result<(), String>>>,
    /// Whether a recent design that is not in memory can be brought back by the host (the browser
    /// build remembers files it saved to the disk); None: it can't.
    pub can_restore: Option<Box<dyn Fn(&str) -> bool>>,
    /// Bring such a design back and open it when it arrives (asks the user for access, so call it
    /// in the click that chose it).
    pub restore_file: Option<Box<dyn Fn(&str)>>,
    /// Show the designs the browser keeps for itself; None: the host has no such store.
    pub browser_files: Option<Box<dyn Fn()>>,
    /// HTTP for the agent chat's API agents (OpenAI-compatible and Anthropic-compatible endpoints); None: no API agents.
    pub agent_http: Option<agent_chat::backend::HttpFn>,
    /// The system keychain, for API agents' keys; None: keys can't be stored.
    pub secrets: Option<std::sync::Arc<dyn agent_chat::backend::Secrets>>,
    /// Upload a model to EasyPrint (Printables' slicer in the browser) and answer with the address
    /// to open (`easyprint_ui`); None: this host can't, and the menu doesn't offer it.
    pub easyprint_upload: Option<easyprint_ui::Upload>,
}

/// The view before a sketch opened and the view that faced the sketch then (#7038).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PreSketchView {
    pub sketch: u64,
    pub before: Camera,
    pub facing: Camera,
}

/// The active component (and placement) before a sketch opened inside another one (#8127), and
/// the component the sketch opened in.
#[derive(Clone, Debug, PartialEq)]
pub struct PreSketchComponent {
    pub sketch: u64,
    pub component: u64,
    pub path: Option<Vec<u64>>,
    pub opened_in: u64,
}

/// The active component (and placement) before a feature row inside a placed component was
/// double-clicked in the Browser, which activates the feature's own component (#12720), and the
/// component the editor opened in.
#[derive(Clone, Debug, PartialEq)]
pub struct PreEditComponent {
    pub feature: u64,
    pub component: u64,
    pub path: Option<Vec<u64>>,
    pub opened_in: u64,
}

/// Which late UI handler has first refusal of this frame's Escape. Reserving input
/// is distinct from having performed cancellation (`esc_handled`).
#[derive(Clone, Copy, Eq, PartialEq)]
pub(crate) enum EscapeOwner {
    Dialog,
    Overlay,
}

pub struct SolveApp {
    /// Common panel foundation, internal opt-in; stays on the app across document tabs.
    pub(crate) panel_runtime: Option<panel_runtime::AppPanelRuntime>,
    /// Current immutable geometry while production content borrows the app.
    pub(crate) panel_content_frame: Option<panel_runtime::HostFrame>,
    pub(crate) panel_layout_preferences: panel_runtime::PanelLayoutPreferences,
    pub blur: blur::State,
    pub(crate) blur_session: blur::Session,
    pub(crate) viewport_status: ui_kit::StatusPresentation,
    pub(crate) viewport_status_fixture: viewport_status_fixture::Fixture,
    /// Compact browser embed: retain model panels and joint controls without application chrome.
    pub embedded: bool,
    /// Editing embed (#8517): the host page owns the files and the window's chrome. No
    /// application bar, no start page, no New/Open/Save/Close or Preferences shortcuts; the
    /// ribbon, browser, timeline and properties stay, and the host reads and replaces the
    /// design through `document.export` / `document.import`.
    pub embed_editor: bool,
    pub session: Session,
    pub ui: UiState,
    pub(crate) shell: shell::State,
    pub cam: Camera,
    /// A view change in progress (axis view, Home, Fit); any mouse navigation cancels it.
    pub cam_anim: Option<CameraAnim>,
    /// The custom view navigator's body (kept with the preferences).
    pub view_gizmo: view_gizmo::State,
    /// Seconds since start, as of this frame.
    pub now: f64,
    /// The views around opening the open sketch. Leaving it goes back to the earlier one as the
    /// "When a sketch ends" preference says (#7038).
    pub pre_sketch_cam: Option<PreSketchView>,
    /// The view from before Extrude turned it to isometric (#9176); the view goes back to it when
    /// the dialog closes, as the "and back when it closes" preference says.
    pub pre_extrude_cam: Option<Camera>,
    /// The view a command that ends an open sketch was clicked in (#10571), taken before the
    /// sketch's own end turns the view: that turn must not become the view Extrude goes back to.
    pre_command_cam: Option<Camera>,
    /// The component active before Edit Sketch activated the one the sketch is in (#8127);
    /// leaving the sketch makes it active again.
    pub pre_sketch_component: Option<PreSketchComponent>,
    /// The component active before a Browser double-click activated the one a feature is in
    /// (#12720); the end of that feature's editor makes it active again.
    pub pre_edit_component: Option<PreEditComponent>,
    pub services: Services,
    file_picker: Option<file_picker::Pending>,
    /// A slicer started alone and waited for before the file is sent (Send to Slicer).
    pub(crate) slicer_wait: Option<dialogs_save_mesh::SlicerWait>,
    /// Open with EasyPrint: the upload in flight and the question before the first one.
    pub(crate) easyprint: easyprint_ui::State,
    /// A Save or Save As being written on a worker (see [`save_job`]).
    saving: Option<save_job::Saving>,
    pub viewport: viewport::ViewportState,
    pub render_workspace: render_workspace::State,
    pub tool: Option<tools::Tool>,
    pub dialog: Option<dialogs::Dialog>,
    /// The joint dialogs' picked and hovered snaps ([`dialogs_assembly::picked_snap`]).
    pub(crate) snaps: dialogs_assembly::SnapMemo,
    /// Each command dialog's options and values as last applied (this session only).
    pub(crate) remembered_commands: Vec<dialogs::RememberedCommand>,
    /// The Change Parameters window, when open.
    pub params: Option<params_dialog::ParamsDialog>,
    /// The Design Properties window, when open.
    pub design_properties: Option<design_properties::DesignProperties>,
    /// The Sketch report window (`sketch.inspect` from the ribbon), when open.
    pub sketch_report: Option<sketch_report::SketchReport>,
    /// The Bill of Materials window, when open.
    pub bom: Option<bom_panel::BomPanel>,
    material_card_review: Option<material_card_review::ReviewWindow>,
    /// Context menus, rename box and Properties window.
    pub menu: context_menu::MenuState,
    /// Mouse gestures: the ring of tools and its customization window.
    pub gesture: mouse_gesture::State,
    /// Browser tree state (reveal, groups being edited, occurrence moves).
    pub tree: browser::TreeState,
    /// A saved design copied for insertion into another open document.
    pub linked_design_clipboard: Option<String>,
    /// The S box (command search at the cursor): recent and pinned commands.
    pub sbox: shortcut_box::ShortcutBox,
    /// Keyboard shortcuts the user changed.
    pub keymap: keymap::Keymap,
    /// The Help menu and the About window.
    pub help: help::HelpState,
    /// Every status message of this run, for the Messages window ([`messages`], #2763).
    pub messages: messages::Messages,
    /// An editable local issue draft and optional captured app frame.
    pub issue_report: issue_report::ReportState,
    /// The Crash Reports window.
    pub crashes: crash_ui::CrashUi,
    /// The update check and its window (`update`).
    pub updater: update::Updater,
    /// Safari's steps for installing the web app, while their window is open (`install`).
    pub install_steps: Option<install::Steps>,
    /// Toolbar buttons the user pinned, removed or reordered.
    pub toolbar_custom: toolbar_custom::ToolbarCustom,
    /// Named settings profiles (#6237).
    pub settings_profiles: settings_profiles::Profiles,
    /// Preferences kept between runs, and their window.
    pub preferences: prefs::Prefs,
    pub prefs_window: prefs::PrefsWindow,
    /// The slicers the Save as mesh dialog offers.
    pub slicer_menu: dialogs_save_mesh::SlicerMenu,
    pub preview: preview::PreviewState,
    /// OK pressed on a feature that takes a while: its evaluation runs off the window thread.
    pub applying: Option<dialogs::Applying>,
    pub(crate) editing_state: Option<dialogs::EditingState>,
    /// A linked component's design edited in place, with its assembly around it.
    pub edit_in_place: edit_in_place::EditInPlace,
    pub(crate) pending_feature_edit: Option<feature_edit::PendingFeatureEdit>,
    /// The feature being reopened from a click and where, until its dialog opens (UI state only).
    edit_anchor_hint: Option<(u64, solidcore_record::Vec3)>,
    /// The open feature window's check of what its material does (#6901).
    pub op_check: op_auto::OpCheck,
    /// A command recomputing the history (the marker moved, undo) computing off the window
    /// thread, and those asked for meanwhile ([`deferred`]).
    pub deferred: Option<deferred::Deferred>,
    pub deferred_queue: Vec<(String, Value)>,
    /// A feature started from a sketch while the marker rolls back, and that sketch: it starts
    /// once the marker is back.
    pub start_after_roll: Option<(String, u64)>,
    /// The ribbon tab before the current `start` moved it to the command's home tab. A command
    /// that starts nothing (refused with a parameter or status error) puts it back (#10540).
    pub(crate) command_tab_before_start: Option<String>,
    pub(crate) timeline_playback: Option<timeline::Playback>,
    /// A delete's check of what it takes with it or breaks, computing off the window thread
    /// ([`deferred::DeleteCheck`], #2678).
    pub delete_check: Option<deferred::DeleteCheck>,
    /// How long OK waits for a feature before computing it off the window thread, saying so;
    /// `None`: it waits as long as it takes (headless use, tests). The desktop app sets it.
    pub apply_off_thread: Option<std::time::Duration>,
    /// One bounded native render proof/retirement owner, independent of tab state.
    pub(crate) render_preparation: render_workspace::prepare::State,
    /// Tests: work started off the window thread (a feature's evaluation, a Properties
    /// measurement) waits for this before it reports done.
    #[cfg(test)]
    pub(crate) apply_gate: Option<std::sync::Arc<std::sync::Mutex<std::sync::mpsc::Receiver<()>>>>,
    /// The last command started interactively (id, label), for Repeat.
    pub last_command: Option<(String, String)>,
    /// Bodies copied with Copy (by name), pasted into the active component by Paste.
    pub copied_bodies: Vec<String>,
    /// Text a copy left for the system clipboard, written on the next frame (so a paste event
    /// follows: the window system sends one only while the clipboard holds text).
    pub(crate) clipboard_text: Option<String>,
    /// Component placements copied with Copy (by path): Paste places new instances of them in
    /// the active component, Paste New (Ctrl+Shift+V) independent copies.
    pub copied_placements: Vec<Vec<u64>>,
    /// Components, timeline features and bodies cut with Cut: they stay until Paste moves them
    /// into a component.
    pub cut: edit_clipboard::CutSet,
    /// Counts copies and cuts in every open design: the last one is what pastes.
    pub clipboard_stamp: u64,
    /// The copy or cut this design made last (`clipboard_stamp` then): when it isn't the last
    /// one, what this design copied is stale and another design's copy pastes.
    pub own_clipboard_stamp: u64,
    /// The bodies (or components) the last copy or cut took, with the design they were in, to
    /// paste into another design (`component.paste_from_design`).
    pub foreign_copy: Option<std::sync::Arc<solidcraft_engine::ForeignCopy>>,
    /// The sketch geometry the last copy or cut took, when it was sketch geometry: a sketch of
    /// another design pastes it (#9258).
    pub foreign_sketch_clip: Option<solidcraft_engine::cmd::sketch_clipboard::SketchClip>,
    /// Esc was already acted on this frame (by the shortcuts), so later handlers skip it.
    pub esc_handled: bool,
    pub(crate) escape_owner: Option<EscapeOwner>,
    /// When Esc was last pressed (input time): a second press soon after finishes the sketch.
    pub last_escape: Option<f64>,
    pub status: Option<(String, f64, bool)>,
    /// The status message offers Undo (a click on it undoes the last step), as after an automatic stand-up.
    pub status_undo: bool,
    pub quit_requested: bool,
    /// Autosave into the recovery folder (the desktop app turns it on).
    pub autosave: Option<recovery_ui::Autosaves>,
    /// Lock files next to the open designs (the desktop app turns them on; #5467).
    pub locks: Option<open_elsewhere::Locks>,
    /// Opens waiting for "this design is open elsewhere" to be answered, first asked first.
    pub lock_prompts: Vec<open_elsewhere::LockPrompt>,
    /// A Save waiting for "the file changed on disk" to be answered.
    pub disk_prompt: bool,
    /// Update Links, Open Linked Design or Reload from file waiting for a network server to be allowed.
    pub network_prompt: Option<network_prompt::NetworkPrompt>,
    /// Designs left by crashed apps, offered for recovery.
    pub recoverable: Vec<solidcraft_engine::recovery::Entry>,
    /// The recovery folder holding this launch's reopen-guard marker (#5064); `None` when
    /// there is no recovery folder. A reopened design that finishes opening is taken off it.
    pub reopen_guard_dir: Option<std::path::PathBuf>,
    /// Discard all was clicked in the recovery window: its confirmation is showing (#9299).
    pub recovery_discard_all: bool,
    /// The selection's measurement in the view's corner (#7000).
    pub(crate) quick_measure: quick_measure::QuickMeasure,
    /// An STL or OBJ file waiting for the unit its coordinates are in (`mesh_units`).
    pub mesh_units: Option<mesh_units::Ask>,
    /// The bodies of a just-opened Y-up file, offered to be stood up (`stand_up`).
    pub stand_up: Option<Vec<String>>,
    /// The placement of the component that file came in as: the offer turns it.
    pub stand_up_occurrence: Option<u64>,
    /// The file's header names an exporter that saves Y up (SolidWorks): the offer says so.
    pub stand_up_reason: bool,
    /// The file brought more than one body or a component tree: the offer says "assembly".
    pub stand_up_assembly: bool,
    /// The offer is the small note over the view, not the dialog (a file from a program not known
    /// to save Y up, Preferences › Design, #7717).
    pub stand_up_note: bool,
    /// When the note was first drawn (the window's clock), or since the pointer was last on it; it
    /// goes after `stand_up::NOTE_SECONDS`.
    pub stand_up_note_since: Option<f64>,
    /// The anti-aliasing sample counts the scene colour/depth formats support (empty without a GPU).
    pub msaa_supported: Vec<u32>,
    /// The startup check selected 1x; Graphics explains the workaround.
    pub msaa_compatibility: bool,
    /// Startup fallback diagnostic, also shown in Graphics preferences.
    pub graphics_fallback: Option<String>,
    /// Settings put back at start because they kept SolidCraft from starting, one line each,
    /// shown until dismissed (`prefs::show_reset_notice`).
    pub settings_reset: Vec<prefs::SettingReset>,
    /// The last command was a big operation: autosave after it.
    pub big_operation: bool,
    /// Autosave interval (minutes; 0 = only after big operations). A preference.
    pub autosave_minutes: f64,
    /// The application bar is the window's title bar (Windows, Linux: no OS decorations).
    pub custom_titlebar: bool,
    /// The OS hit test already offers the resize border ([`titlebar`]; the Windows desktop app),
    /// so no egui resize zones are laid out.
    pub native_resize_border: bool,
    /// macOS: the traffic lights sit over the application bar's left end.
    pub integrated_titlebar: bool,
    /// The desktop host installed native menus alongside the application bar controls.
    pub native_file_menu: bool,
    /// Where the application bar puts search, Report a bug and the version (set by the host).
    pub header: toolbar::HeaderLayout,
    /// Build bodies' display meshes on the CPU even where the GPU could (safe mode). Read by
    /// [`SolveApp::set_wgpu`].
    pub cpu_meshing: bool,
    pub frame_ms: f64,
    /// The viewport's frame-rate readout ([`frame_rate`]).
    pub frame_rate: frame_rate::FrameRate,
    pub synthetic: Vec<egui::Event>,
    /// The modifiers of the synthetic press in progress (a Ctrl-drag keeps Ctrl while it moves).
    pub synthetic_mods: egui::Modifiers,
    /// A click that came in the same frame as typing before it, held for the next frame.
    held_click: Vec<egui::Event>,
    /// A synthetic press is held: its drag never moves the real cursor (`navigation::wrap_cursor`).
    pub(crate) synthetic_press: bool,
    control_rx: Option<Receiver<ControlRequest>>,
    /// Control requests that change the design, held while a file loads or an agent's design
    /// change computes.
    control_held: std::collections::VecDeque<ControlRequest>,
    /// An agent's design change computing off the window thread ([`control_job`]).
    control_job: Option<control_job::ControlJob>,
    /// Agent exports computing on copies of the design.
    control_answering: Vec<control_job::ControlJob>,
    /// The agent cursor acting out control requests.
    pub agent: agent_cursor::AgentCursor,
    /// The agent chat panel (docs/design/in-app-agent-chat.md).
    pub agent_chat: agent_chat::AgentChat,
    /// Making SolidCraft available to the AI apps installed here ([`ai_connect`]).
    pub ai_connect: ai_connect::State,
    pending_shots: Vec<(u64, Option<String>, std::sync::mpsc::Sender<Value>, f64)>,
    shot_chat_turns: std::collections::HashMap<u64, std::sync::Arc<std::sync::atomic::AtomicBool>>,
    queued_shots: Vec<(u64, f64, u32)>,
    /// Screenshots egui hands back, by token; egui calls back, `collect_screenshots` reads them.
    shot_tx: std::sync::mpsc::Sender<(u64, std::sync::Arc<egui::ColorImage>)>,
    shot_rx: std::sync::mpsc::Receiver<(u64, std::sync::Arc<egui::ColorImage>)>,
    shot_token: u64,
    styled: bool,
    fitted: bool,
    /// A framing to settle once the viewport's layout is known: the camera to frame from, the
    /// bounds, whether to glide there, and whether it is the navigators' shared-zoom framing.
    pending_fit: Option<(Camera, solidcraft_engine::geom::Aabb3, bool, bool)>,
    /// Frames a pending fit has waited for a layout that can frame it (`resolve_fit`).
    fit_waits: u32,
    /// The sheet metal flat pattern's own pan and zoom.
    pub flat_view: dialogs_sheet::FlatView,
    /// The start page.
    pub home: home::HomeState,
    /// The 3D mouse: which device, its reading, and the calibration window.
    pub space_mouse: space_mouse::Input,
    pub file_load: file_load::FileLoad,
    /// An opened design's bodies still being meshed, off the UI thread.
    pub(crate) open_meshing: Option<open_meshing::Meshing>,
    /// A design is being put in the window and will be meshed after it: framing it uses outlines.
    pub(crate) open_meshing_next: bool,
    /// How long each frame takes on the window thread, by phase.
    pub(crate) frame_watch: frame_watch::Watch,
    /// The other open designs (tabs).
    pub docs: documents::Documents,
    /// The language the installed font fallback chain is ordered for (`fonts::fallback_order`);
    /// changing `preferences.language` re-installs the fonts on the next frame.
    applied_fonts_language: String,
    /// The interface font the fonts were last set up with (`Prefs::ui_font`).
    applied_ui_font: String,
    /// The fonts installed include the system's fallback faces.
    applied_system_fonts: bool,
}

impl Drop for SolveApp {
    /// The Home pictures it started are drawn before it goes: one still on the GPU as the
    /// process exits can crash the graphics driver.
    fn drop(&mut self) {
        #[cfg(not(target_arch = "wasm32"))]
        home::finish_pictures(&mut self.home, std::time::Duration::from_secs(10));
    }
}

impl SolveApp {
    pub fn new(mut session: Session, services: Services) -> Self {
        #[cfg(test)]
        let image_host = Some(solidcraft_engine::render::job::CpuHost::cooperative());
        #[cfg(not(test))]
        let image_host = solidcraft_engine::render::job::CpuHost::for_platform().map_err(|e| log::error!("render image host: {e}")).ok();
        if let Err(e) = session.set_render_job_host(image_host.clone()) {
            log::error!("render image host: {e}");
        }
        let mut render_workspace = render_workspace::State::default();
        render_workspace.image_host = image_host;
        #[cfg(not(target_arch = "wasm32"))]
        solidcraft_engine::slicer_files::clean_old();
        let tree = browser::TreeState::for_session(session.uid);
        let (shot_tx, shot_rx) = std::sync::mpsc::channel();
        let mut app = SolveApp {
            panel_runtime: None,
            panel_content_frame: None,
            panel_layout_preferences: panel_runtime::PanelLayoutPreferences::default(),
            viewport_status: Default::default(),
            blur: Default::default(),
            blur_session: Default::default(),
            viewport_status_fixture: Default::default(),
            session,
            ui: UiState::default(),
            shell: Default::default(),
            cam: Camera::default(),
            cam_anim: None,
            view_gizmo: view_gizmo::State::default(),
            now: 0.0,
            pre_sketch_cam: None,
            pre_extrude_cam: None,
            pre_command_cam: None,
            pre_sketch_component: None,
            pre_edit_component: None,
            services,
            file_picker: None,
            slicer_wait: None,
            easyprint: Default::default(),
            saving: None,
            viewport: viewport::ViewportState::default(),
            render_workspace,
            tool: None,
            dialog: None,
            snaps: Default::default(),
            remembered_commands: Vec::new(),
            params: None,
            design_properties: None,
            sketch_report: None,
            bom: None,
            material_card_review: None,
            menu: context_menu::MenuState::default(),
            gesture: mouse_gesture::State::default(),
            tree,
            linked_design_clipboard: None,
            sbox: shortcut_box::ShortcutBox::default(),
            keymap: keymap::Keymap::default(),
            help: help::HelpState::default(),
            messages: messages::Messages::default(),
            issue_report: issue_report::ReportState::default(),
            crashes: crash_ui::CrashUi::default(),
            updater: update::Updater::default(),
            install_steps: None,
            toolbar_custom: toolbar_custom::ToolbarCustom::default(),
            settings_profiles: settings_profiles::Profiles::default(),
            preferences: prefs::Prefs::default(),
            prefs_window: prefs::PrefsWindow::default(),
            slicer_menu: dialogs_save_mesh::SlicerMenu::default(),
            preview: preview::PreviewState::default(),
            applying: None,
            editing_state: None,
            edit_in_place: Default::default(),
            pending_feature_edit: None,
            edit_anchor_hint: None,
            op_check: op_auto::OpCheck::default(),
            deferred: None,
            deferred_queue: Vec::new(),
            start_after_roll: None,
            command_tab_before_start: None,
            timeline_playback: None,
            delete_check: None,
            apply_off_thread: None,
            render_preparation: Default::default(),
            #[cfg(test)]
            apply_gate: None,
            last_command: None,
            copied_bodies: Vec::new(),
            clipboard_text: None,
            copied_placements: Vec::new(),
            cut: Default::default(),
            clipboard_stamp: 0,
            own_clipboard_stamp: 0,
            foreign_copy: None,
            foreign_sketch_clip: None,
            esc_handled: false,
            escape_owner: None,
            last_escape: None,
            status: None,
            status_undo: false,
            quit_requested: false,
            autosave: None,
            locks: None,
            lock_prompts: Vec::new(),
            disk_prompt: false,
            network_prompt: None,
            recoverable: Vec::new(),
            reopen_guard_dir: None,
            recovery_discard_all: false,
            quick_measure: Default::default(),
            mesh_units: None,
            stand_up: None,
            stand_up_occurrence: None,
            stand_up_reason: false,
            stand_up_assembly: false,
            stand_up_note: false,
            stand_up_note_since: None,
            msaa_supported: Vec::new(),
            msaa_compatibility: false,
            graphics_fallback: None,
            settings_reset: Vec::new(),
            big_operation: false,
            autosave_minutes: 5.0,
            custom_titlebar: false,
            native_resize_border: false,
            integrated_titlebar: false,
            native_file_menu: false,
            header: toolbar::HeaderLayout::DESKTOP,
            cpu_meshing: false,
            frame_ms: 0.0,
            frame_rate: frame_rate::FrameRate::default(),
            synthetic: Vec::new(),
            synthetic_mods: egui::Modifiers::default(),
            held_click: Vec::new(),
            synthetic_press: false,
            control_rx: None,
            agent_chat: Default::default(),
            ai_connect: Default::default(),
            control_held: Default::default(),
            control_job: None,
            control_answering: Vec::new(),
            agent: Default::default(),
            pending_shots: Vec::new(),
            shot_chat_turns: Default::default(),
            queued_shots: Vec::new(),
            shot_tx,
            shot_rx,
            shot_token: 0,
            styled: false,
            fitted: false,
            pending_fit: None,
            fit_waits: 0,
            flat_view: Default::default(),
            embedded: false,
            embed_editor: false,
            home: home::HomeState::default(),
            space_mouse: Default::default(),
            file_load: file_load::FileLoad::default(),
            open_meshing: None,
            open_meshing_next: false,
            frame_watch: Default::default(),
            docs: documents::Documents::default(),
            applied_fonts_language: "en".into(),
            applied_ui_font: String::new(),
            applied_system_fonts: false,
        };
        easyprint_ui::install(&mut app);
        app
    }

    /// Translate text using the active language preference.
    pub fn tr<'a>(&self, text: &'a str) -> &'a str {
        i18n::Locale::for_language(&self.preferences.language).text(text)
    }

    /// Translate a display label supplied by the engine, without changing its identifier.
    pub fn tr_label<'a>(&self, text: &'a str) -> &'a str {
        i18n::Locale::for_language(&self.preferences.language).label(text)
    }

    /// Draw the viewport on the GPU (eframe's wgpu render state, with the app's depth and
    /// stencil buffer bits and MSAA sample count). Without it the viewport renders on the CPU.
    /// The scene is drawn in a pass of the same kind as the window's.
    pub fn set_wgpu(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) {
        let target = crate::gpu::GpuTarget {
            format: rs.target_format,
            depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),
            samples: samples.max(1),
            tess: false,
            oit: false,
        };
        self.set_wgpu_targets(rs, target, target);
    }

    /// Draw the viewport on the GPU with the scene drawn offscreen: `depth_bits`/`stencil_bits`
    /// and `samples` are the scene's, while the window's pass (egui's) has no depth and one
    /// sample. Native hosts check the installed renderer and fall back to 1x only when that
    /// succeeds where multisampling fails. Returns the effective scene sample count.
    pub fn set_wgpu_split(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) -> u32 {
        let scene = crate::gpu::GpuTarget {
            format: rs.target_format,
            depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),
            samples: samples.max(1),
            tess: false,
            oit: false,
        };
        let window = crate::gpu::GpuTarget { format: rs.target_format, depth: None, samples: 1, tess: false, oit: false };
        self.set_wgpu_targets(rs, scene, window);
        self.viewport.gpu.map_or(samples, |g| g.samples)
    }

    fn set_wgpu_targets(&mut self, rs: &egui_wgpu::RenderState, scene: crate::gpu::GpuTarget, window: crate::gpu::GpuTarget) {
        self.blur.install(rs, scene.depth.is_some() && window.depth.is_none() && window.samples == 1);
        #[allow(unused_mut)] // Only native hosts can wait for the startup readback.
        let (mut installed, stats, tess_ready) = gpu::install(rs, scene, window, !self.cpu_meshing);
        #[cfg(not(target_arch = "wasm32"))]
        if scene.depth.is_some() && window.depth.is_none() && window.samples == 1 {
            let mut renderer = rs.renderer.write();
            if let Some(res) = renderer.callback_resources.get_mut::<gpu::Renderer>() {
                match res.check_msaa(&rs.device, &rs.queue) {
                    Ok(solidcraft_gpu::view::MsaaCheck::Passed) => {}
                    Ok(solidcraft_gpu::view::MsaaCheck::Fallback) => {
                        installed.samples = 1;
                        self.msaa_compatibility = true;
                        eprintln!(
                            "SolidCraft graphics: anti-aliasing check failed at {}x and passed at 1x; using 1x for this session",
                            scene.samples
                        );
                    }
                    Ok(solidcraft_gpu::view::MsaaCheck::FailedAtOne) => {
                        eprintln!("SolidCraft graphics: anti-aliasing check also failed at 1x; keeping {}x", scene.samples);
                    }
                    Err(error) => eprintln!("SolidCraft graphics: anti-aliasing check error; keeping {}x: {error}", scene.samples),
                }
            }
        }
        self.viewport.gpu = Some(installed);
        self.viewport.tess_ready = tess_ready;
        self.viewport.draw_stats = Some(stats);
        // The device's own limits (what it was created with), not the adapter's: uploads are split
        // at the device's buffer size.
        self.render_workspace.geometry_budget = render_workspace::geometry_budget(rs.device.limits().max_buffer_size, cfg!(target_arch = "wasm32"));
        render_workspace::invalidate_scene(self);
        let (samples, has_depth) = self.viewport.gpu.map_or((1, false), |g| (g.samples.max(1), g.depth.is_some()));
        self.render_workspace.host = match render_workspace::host_executor(rs.device.limits().max_texture_dimension_2d, has_depth, samples) {
            Ok(executor) => Some(executor),
            Err(error) => {
                self.set_status(error, true);
                None
            }
        };
        #[cfg(not(target_arch = "wasm32"))]
        {
            let adapter = rs.adapter.clone();
            let key = render_workspace::adapter_key(&adapter.get_info());
            // Next to the graphics settings: a setup that stops the app is not run again by itself.
            let marker = self.services.graphics_path.as_deref().map(|p| std::path::Path::new(p).with_file_name(render_workspace::SETUP_MARKER));
            self.render_workspace.watch_setup(marker);
            self.render_workspace.defer_path_host(key, move || solidcraft_gpu::path::host_on_adapter(&adapter).map_err(|e| e.to_string()));
        }
        render_workspace::sync_backend(self);
        ai_connect::tick(self);
        self.msaa_supported = rs.msaa_supported.clone();
        let info = rs.adapter.get_info();
        self.help.gpu = Some(format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type));
        self.viewport.adapter = format!("{:?} · {}", info.backend, info.name);
    }

    /// Preferences as JSON for inspection and compatibility. Storage hosts use
    /// `try_prefs` and retain the stored panel record if portable conversion refuses.
    pub fn prefs(&self) -> String {
        self.try_prefs().unwrap_or_else(|reason| {
            log::warn!("Preferences export retained recovery data: {reason}");
            self.prefs_with_panel_layout(prefs::held_panel_layout(self).unwrap_or_else(|| panel_runtime::preferences_value(self)))
        })
    }

    /// Portable preferences for storage. On refusal the host retains its stored panel record.
    pub fn try_prefs(&self) -> Result<String, String> {
        let layout = prefs::held_panel_layout(self).unwrap_or_else(|| panel_runtime::preferences_value(self));
        let portable = panel_runtime::portable_preferences_value(self, layout).map_err(solidcraft_engine::panels::commands::error_text)?;
        Ok(self.prefs_with_panel_layout(portable))
    }

    /// Save ordinary settings after portable layout conversion refuses, retaining the
    /// exact previous panel record (including null or absence). Invalid stored JSON
    /// refuses the whole write rather than replacing recovery data.
    pub fn prefs_with_stored_panel_layout(&self, previous: Option<&str>) -> Result<String, String> {
        let panel_layout = match previous {
            None => None,
            Some(previous) => {
                let value: Value = serde_json::from_str(previous).map_err(|reason| format!("stored preferences are invalid: {reason}"))?;
                let object = value.as_object().ok_or_else(|| "stored preferences must be an object".to_owned())?;
                object.get(panel_runtime::PREFERENCES_KEY).cloned()
            }
        };
        Ok(self.prefs_with_panel_layout(panel_layout))
    }

    fn prefs_with_panel_layout(&self, panel_layout: Option<Value>) -> String {
        let mut v = json!({
            "dark": self.ui.dark,
            "grid": self.ui.show_grid,
            "navigation_bar": self.ui.show_navigation_bar,
            "tool_cursor": self.ui.tool_cursor,
            "perspective": self.ui.perspective,
            "auto_ortho_faces": self.ui.auto_ortho_faces,
            "pick_bodies": self.ui.pick_bodies,
            "auto_project": self.session.auto_project,
            "project_construction": self.session.project_construction,
            "visual_style": self.ui.visual_style,
            "browser_collapsed": self.tree.collapsed,
            "browser_expanded": self.tree.expanded,
            "history_folds": history_folds::prefs(self),
            "recent": self.home.recent,
            "recent_opened_at": self.home.opened_at,
            "recent_forgotten": self.home.forgotten,
            "shortcut_box": self.sbox.prefs(),
            "shortcuts": self.keymap.prefs(),
            "toolbar": self.toolbar_custom.prefs(),
            "settings_profiles": self.settings_profiles.prefs(),
            "autosave_minutes": self.autosave_minutes,
            "ground_shadow": self.ui.ground_shadow,
            "agent_cursor": self.ui.agent_cursor,
            "recent_colors": self.ui.recent_colors,
            "preferences": self.preferences,
            "view_gizmo": self.view_gizmo.stored(),
            "gpu_path_setup_seconds": self.render_workspace.setup_seconds,
        });
        if let Some(layout) = panel_layout
            && let Some(obj) = v.as_object_mut()
        {
            obj.insert(panel_runtime::PREFERENCES_KEY.into(), layout);
        }
        // While the Preferences dialog is open the file holds what Cancel would restore: a change
        // that was never applied must not reach disk through the periodic save, a quit or a
        // window close (#9730). One change covers every writer — desktop save and on_exit, the
        // web app's save, and the control channel.
        if let Some(held) = prefs::held_overlay(self)
            && let Some(obj) = v.as_object_mut()
        {
            for (key, value) in held {
                obj.insert(key, value);
            }
        }
        v.to_string()
    }

    /// Restore preferences saved with [`SolveApp::prefs`].
    pub fn load_prefs(&mut self, prefs: &str) {
        let Ok(v) = serde_json::from_str::<Value>(prefs) else { return };
        let flag = |k: &str| v.get(k).and_then(Value::as_bool);
        self.home.opened_at = v.get("recent_opened_at").and_then(|x| serde_json::from_value(x.clone()).ok()).unwrap_or_default();
        if let Some(d) = flag("dark") {
            self.ui.dark = d;
        }
        if let Some(t) = v.get("gpu_path_setup_seconds") {
            self.render_workspace.setup_seconds = render_workspace::load_setup_seconds(t);
        }
        if let Some(g) = flag("grid") {
            self.ui.show_grid = g;
        }
        if let Some(visible) = flag("navigation_bar") {
            self.ui.show_navigation_bar = visible;
        }
        if let Some(visible) = flag("tool_cursor") {
            self.ui.tool_cursor = visible;
        }
        if let Some(p) = flag("perspective") {
            self.ui.perspective = p;
        }
        if let Some(a) = flag("auto_ortho_faces") {
            self.ui.auto_ortho_faces = a;
        }
        if let Some(b) = flag("pick_bodies") {
            self.ui.pick_bodies = b;
        }
        if let Some(a) = flag("auto_project") {
            self.session.auto_project = a;
        }
        if let Some(c) = flag("project_construction") {
            self.session.project_construction = c;
        }
        if let Some(m) = v.get("autosave_minutes").and_then(Value::as_f64).filter(|m| m.is_finite()) {
            self.autosave_minutes = m.clamp(0.0, 600.0);
        }
        if let Some(s) = v.get("visual_style").and_then(Value::as_u64) {
            self.ui.visual_style = u8::try_from(s.min(3)).unwrap_or(0);
        }
        // Browser folders the user opened or closed.
        let keys = |k: &str| -> std::collections::BTreeSet<String> {
            v.get(k)
                .and_then(Value::as_array)
                .map(|a| a.iter().take(10_000).filter_map(|x| x.as_str().map(str::to_string)).collect())
                .unwrap_or_default()
        };
        self.tree.collapsed = keys("browser_collapsed");
        self.tree.expanded = keys("browser_expanded");
        history_folds::load_prefs(self, &v);
        self.home.recent = v
            .get("recent")
            .and_then(Value::as_array)
            .map(|a| a.iter().filter_map(Value::as_str).take(home::MAX_RECENT).map(str::to_string).collect())
            .unwrap_or_default();
        self.home.forgotten = keys("recent_forgotten");
        if let Some(s) = v.get("shortcut_box") {
            self.sbox.load(s);
        }
        if let Some(s) = v.get("shortcuts") {
            self.keymap.load(s);
        }
        if let Some(t) = v.get("toolbar") {
            self.toolbar_custom.load(t);
        }
        if let Some(p) = v.get("settings_profiles") {
            self.settings_profiles.load(p);
        }
        self.view_gizmo.load(v.get("view_gizmo"));
        if let Some(mut p) = v.get("preferences").filter(|p| p.is_object()).map(prefs::lenient) {
            if !prefs::MSAA.contains(&p.msaa) {
                p.msaa = prefs::Prefs::default().msaa;
            }
            self.ui.layout = p.layout;
            self.preferences = p;
        }
        // Before a design given at start opens: its paths follow the network preferences.
        prefs::sync_surface_analysis(self);
        prefs::apply_network(&self.preferences);
        // Before a file given at start opens: the largest file it may be (#4086).
        prefs::apply_file_limits(&self.preferences);
        // Saved before the theme was a preference: the Dark/Light flag says which.
        if v.get("preferences").and_then(|p| p.get("theme")).is_none() {
            self.preferences.theme = if self.ui.dark { "dark" } else { "light" }.into();
        }
        if let Some(g) = flag("ground_shadow") {
            self.ui.ground_shadow = g;
        }
        if let Some(a) = v.get("agent_cursor").and_then(|a| serde_json::from_value(a.clone()).ok()) {
            self.ui.agent_cursor = a;
        }
        // Colours that do not read (not three bytes) are left out; the list is capped.
        self.ui.recent_colors = v
            .get("recent_colors")
            .and_then(Value::as_array)
            .map(|a| a.iter().filter_map(|c| serde_json::from_value::<[u8; 3]>(c.clone()).ok()).take(recent_colors::MAX_RECENT_COLORS).collect())
            .unwrap_or_default();
        panel_runtime::load_preferences(self, &v);
    }

    pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {
        self.control_rx = Some(rx);
        self
    }

    /// Run a command programmatically (JSON parameters, no dialogs).
    pub fn run(&mut self, id: &str, params: Value) -> Result<Value, String> {
        if solidcraft_engine::panels::commands::is_command(id) {
            return self.run_panel_command(id, &params).map_err(solidcraft_engine::panels::commands::error_text);
        }
        if self.file_load.busy() || self.file_picker.is_some() || self.saving.is_some() {
            return Err("a file operation is in progress".into());
        }
        // The editor's own marker moves come through here, so only Undo, Redo and Play close it.
        if matches!(id, "edit.undo" | "edit.redo" | "timeline.play") {
            self.close_editor_for_history()?;
        }
        // Commands may start only detected slicers and the programs the user added under Custom….
        if matches!(id, "file.save_mesh" | "file.send_to_slicer") {
            solidcraft_engine::slicers::set_chosen_programs(&self.preferences.custom_slicers);
        }
        self.session.set_validation(self.preferences.validation);
        if id == "timeline.play" {
            let reply = self.session.execute(id, &params).map_err(|e| e.to_string())?;
            let action = serde_json::from_value(reply["action"].clone()).map_err(|e| e.to_string())?;
            timeline::request_playback(self, action)?;
            return Ok(reply);
        }
        let t0 = now_ms();
        let revision = self.session.revision;
        if matches!(id, "render.lights.solo" | "render.lights.mute") {
            render_workspace::light::validate_visibility(self, &params)?;
        }
        let params = if matches!(id, "render.start" | "render.preflight") { render_workspace::light::filter_request(self, params)? } else { params };
        let selected_before = self.session.selection.clone();
        let r = self.session.execute(id, &params).map_err(|e| e.to_string()).and_then(|reply| {
            render_workspace::apply_command(self, id, &reply)?;
            Ok(reply)
        });
        self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS;
        self.after_command(id, &params, revision, selected_before, r)
    }

    /// Commit already prepared rendering through the same window post-hooks,
    /// without executing capture or admission again on the window.
    pub(crate) fn finish_render_preparation(
        &mut self,
        id: &str,
        params: &Value,
        finish: impl FnOnce(&mut Session) -> Result<Value, String>,
    ) -> Result<Value, String> {
        let revision = self.session.revision;
        let selected_before = self.session.selection.clone();
        let result = finish(&mut self.session).and_then(|reply| {
            render_workspace::apply_command(self, id, &reply)?;
            Ok(reply)
        });
        self.after_command(id, params, revision, selected_before, result)
    }

    fn after_command(
        &mut self,
        id: &str,
        params: &Value,
        revision: u64,
        selected_before: Vec<solidcraft_engine::Sel>,
        r: Result<Value, String>,
    ) -> Result<Value, String> {
        // An Undo offered by the last toast is stale once another command changed the design.
        if self.status_undo && revision != self.session.revision {
            self.status_undo = false;
            self.status = None;
        }
        let done = self.command_completed(id, r);
        if self.session.revision != revision {
            timeline::stop_playback(self);
        }
        let selection_changed = self.session.selection != selected_before || matches!(id, "select.set" | "select.clear" | "select.same_look");
        if done.is_ok() && selection_changed {
            self.tree.clear_folder_pick();
        }
        // Render focus already applies its semantic selection after clearing object picks.
        // A tab switch brings in the other design's own Render selection.
        if done.is_ok() && !matches!(id, "view.render_select" | "view.next_tab" | "view.previous_tab") && selection_changed {
            let selection = render_workspace::object_selection(self);
            if render_workspace::active(self) {
                render_workspace::selection_editor(self, &selection);
            } else {
                self.render_workspace.view.selection = selection;
            }
        }
        if let Ok(v) = &done {
            if matches!(id, "render.lights.solo" | "render.lights.mute") {
                render_workspace::light::apply_visibility(self, id, v);
            }
            if matches!(id, "render.lights.set" | "render.lights.add" | "render.lights.duplicate" | "render.lights.remove") {
                render_workspace::light::edited(self, id, params, v);
            }
        }
        done
    }

    /// Host effects shared by directly executed and already evaluated commands.
    pub(crate) fn command_completed(&mut self, id: &str, r: Result<Value, String>) -> Result<Value, String> {
        // The engine has no edit in place to start or finish; the window does, and says when it can't.
        let r = match solidcraft_engine::find_command(id).map(|spec| spec.id) {
            // `queued`: it waits for the end of the agent's turn.
            Some("component.edit_in_place") => r.and_then(|v| edit_in_place::command_ran(self, &v).map(|queued| with_queued(v, queued))),
            Some("component.finish_edit") => r.and_then(|v| edit_in_place::finish_command(self).map(|queued| with_queued(v, queued))),
            _ => r,
        };
        if let Ok(v) = &r {
            match id {
                "sketch.finish" | "sketch.cancel" => self.sketch_closed(v.get("sketch").and_then(Value::as_u64)),
                // The sketch being edited has all new contents: a tool's picks named the old ones.
                "sketch.replace" if v.get("sketch_id").and_then(Value::as_u64).is_some_and(|id| self.session.active_sketch == Some(id)) => {
                    if let Some(tool) = self.tool.as_mut() {
                        tool.pts.clear();
                        tool.hover = None;
                        tool.picks.clear();
                        tool.point_picks.clear();
                    }
                }
                "view.fit" | "view.home" => self.frame_view(id == "view.home"),
                "view.tool" => {
                    self.viewport.nav = match v.get("tool").and_then(Value::as_str) {
                        Some("orbit") => Some(viewport::NavMode::Orbit),
                        Some("pan") => Some(viewport::NavMode::Pan),
                        Some("zoom") => Some(viewport::NavMode::Zoom),
                        _ => None,
                    };
                }
                "view.tool.zoom" => {
                    let active = self.viewport.nav == Some(viewport::NavMode::Zoom);
                    if v.get("on").and_then(Value::as_bool).unwrap_or(!active) {
                        self.viewport.nav = Some(viewport::NavMode::Zoom);
                    } else if active {
                        self.viewport.nav = None;
                    }
                }
                "view.spin" => {
                    self.cancel_view_animation();
                    self.viewport.spin = v.get("on").and_then(Value::as_bool).unwrap_or(!self.viewport.spin);
                }
                "view.visual_style" => {
                    if let Some(index) = v.get("index").and_then(Value::as_u64).and_then(|n| u8::try_from(n).ok()) {
                        self.ui.visual_style = index;
                    }
                }
                // The command and the preference are one setting.
                "diagnostics.validation" => self.preferences.validation = self.session.validation(),
                "view.grid" => self.ui.show_grid = v.get("on").and_then(Value::as_bool).unwrap_or(!self.ui.show_grid),
                "view.ground_shadow" => self.ui.ground_shadow = v.get("on").and_then(Value::as_bool).unwrap_or(!self.ui.ground_shadow),
                "view.navigation_bar" => {
                    self.ui.show_navigation_bar = v.get("visible").and_then(Value::as_bool).unwrap_or(!self.ui.show_navigation_bar)
                }
                "view.next_tab" | "view.previous_tab" => documents::cycle(self, id == "view.next_tab"),
                "view.ribbon_tabs_only" => {
                    let on = v.get("on").and_then(Value::as_bool).unwrap_or(!self.preferences.ribbon_tabs_only);
                    self.preferences.ribbon_tabs_only = on;
                    self.ui.ribbon_open = false;
                }
                // An edit OK'd on a feature behind the history marker changes nothing in the view:
                // say why, or the edit looks as if it had silently failed (#8100).
                "timeline.redefine" if v.get("rolled_back").and_then(Value::as_bool) == Some(true) => {
                    let feature = v.get("feature").and_then(Value::as_u64).and_then(|f| self.session.doc.feature(f));
                    let name = feature.map(|f| f.name.clone()).unwrap_or_default();
                    self.set_status(i18n::format("timeline.edited_rolled_back", &[("name", &name)]), false);
                }
                _ => {}
            }
            if id == "view.render_inspector" {
                render_workspace::set_inspector_visible(self, v.get("visible").and_then(Value::as_bool).unwrap_or(true));
            }
            if id == "view.render_live"
                && let Some(paused) = v.get("paused").and_then(Value::as_bool)
            {
                render_workspace::live::set_paused(self, paused);
            }
            if id == "view.render_browser" {
                render_workspace::apply_browser_controls(self, v);
            }
            if id == "appearance.favorite" {
                render_workspace::assign::favorite_applied(self, v);
            }
            if id == "view.render_frame" {
                render_workspace::shot::apply_frame(self, v);
            }
            if id == "view.render_select" {
                use render_workspace::RenderSelection;
                let selected = match v.get("kind").and_then(Value::as_str) {
                    Some("environment") => RenderSelection::Environment,
                    Some("wear") => RenderSelection::Wear,
                    Some("lighting") => RenderSelection::Lighting,
                    Some("output") => RenderSelection::Output,
                    Some("sampling") => RenderSelection::Sampling,
                    Some("effects") => RenderSelection::Effects,
                    Some("check") => RenderSelection::Check,
                    Some("light") => RenderSelection::Light(v.get("id").and_then(Value::as_str).unwrap_or_default().into()),
                    Some("shot") => RenderSelection::Shot(v.get("id").and_then(Value::as_str).unwrap_or_default().into()),
                    _ => RenderSelection::Nothing,
                };
                render_workspace::selection_editor(self, &selected);
            }
            if id == "view.layout" {
                let layout =
                    if v.get("mode").and_then(Value::as_str) == Some("compact") { shell::LayoutMode::Docked } else { shell::LayoutMode::Floating };
                self.preferences.layout = layout;
                self.ui.layout = layout;
            }
            if matches!(id, "browser.expand_all" | "browser.collapse_all") {
                let strings = |key: &str| -> Vec<String> {
                    v.get(key)
                        .and_then(Value::as_array)
                        .map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).take(10_000).collect())
                        .unwrap_or_default()
                };
                browser::apply_fold(
                    self,
                    v.get("open").and_then(Value::as_bool).unwrap_or(id == "browser.expand_all"),
                    &strings("open_by_default"),
                    &strings("closed_by_default"),
                );
            }
            if id == "view.render_focus"
                && let Some(on) = v.get("on").and_then(Value::as_bool)
            {
                self.shell.render_focus = on;
                render_ui::reset_shell(self);
                self.shell.content = None;
            }
            if id == "view.render_browser"
                && let Some(open) = v.get("open").and_then(Value::as_bool)
            {
                self.shell.render_browser_open = open;
            }
            if id == "view.render_stage"
                && let Some(stage) = v.get("stage").and_then(Value::as_str)
            {
                render_workspace::select_stage(self, stage);
            }
            if id == "select.filter" {
                let mode = v.get("mode").and_then(Value::as_str);
                self.ui.pick_bodies = mode == Some("body");
                self.ui.pick_components = mode == Some("component");
                self.ui.pick_off.retain(|kind| kind != "faces");
            }
            if id == "view.render_dock"
                && let (Some(panel), Some(side)) = (v.get("panel").and_then(Value::as_str), v.get("side").and_then(Value::as_str))
            {
                let other = if side == "left" { "right" } else { "left" };
                if panel == "inspector" {
                    self.preferences.render_inspector_side = side.into();
                    self.preferences.render_browser_side = other.into();
                } else {
                    self.preferences.render_browser_side = side.into();
                    self.preferences.render_inspector_side = other.into();
                }
            }
            if id == "view.shots_strip"
                && let Some(visible) = v.get("visible").and_then(Value::as_bool)
            {
                self.preferences.render_shots_strip = visible;
            }
            if id == "view.history_layout" {
                if let Some(width) = v.get("width").and_then(Value::as_f64) {
                    self.preferences.timeline_left_width = ui_kit::history_snap_width(width as f32);
                }
                if let Some(dock) = v.get("dock").and_then(Value::as_str) {
                    self.preferences.timeline_left = !matches!(dock, "bottom" | "browser");
                    self.preferences.history_in_browser = dock == "browser";
                    self.preferences.timeline_under_browser = dock == "under_browser";
                    self.preferences.timeline_collapsed = false;
                    self.preferences.timeline_left_browser_collapsed = false;
                }
                if let Some(collapsed) = v.get("collapsed").and_then(Value::as_bool) {
                    self.preferences.timeline_collapsed = collapsed;
                }
            }
            if id == "view.perspective"
                && let Some(perspective) = v.get("enabled").and_then(Value::as_bool)
            {
                self.ui.perspective = perspective;
            }
            if id == "view.angle_readout" {
                self.preferences.show_view_angles = v.get("enabled").and_then(Value::as_bool).unwrap_or(false);
            }
            if matches!(id, "view.ambient_occlusion" | "view.graphics_preset") {
                self.preferences.ambient_occlusion = v.get("enabled").and_then(Value::as_bool).unwrap_or(false);
                if id == "view.graphics_preset" {
                    self.preferences.display_quality = v.get("display_quality").and_then(Value::as_str).unwrap_or("normal").to_string();
                    self.preferences.supersampling = v.get("supersampling").and_then(Value::as_f64).unwrap_or(1.0) as f32;
                    self.preferences.supersampling_adaptive = v.get("supersampling_adaptive").and_then(Value::as_bool).unwrap_or(true);
                }
            }
            if id == "view.navigate" {
                let to: Camera = serde_json::from_value(v.get("camera").cloned().unwrap_or_default()).map_err(|e| e.to_string())?;
                // A locked view angle (#4581) never moves with the mouse or the arrow keys.
                let to = crate::view_angles::keep_locked(self, self.cam, to);
                if v.get("continuous").and_then(Value::as_bool).unwrap_or(false) {
                    self.cancel_view_animation();
                    self.cam = to;
                } else if v.get("fit").and_then(Value::as_bool).unwrap_or(false) {
                    self.animate_to_fitted(to);
                } else {
                    self.animate_to(to);
                }
            }
            // Curves drawn in construction (or centerline) mode take that line type.
            sketch_palette::apply_mode(self, id, v);
        }
        // Settings profiles live in the app: the engine only checked the parameters.
        let r = match r {
            Ok(v) if id.starts_with("settings.profile.") => settings_profiles::command(self, id, &v),
            // The view navigator is the app's too.
            Ok(v) if id == "view.navigator" => view_gizmo::command(self, &v),
            r => r,
        };
        self.finish_command(id, &r);
        if render_workspace::active(self)
            && matches!(id, "appearance.assign" | "appearance.paste")
            && let Ok(value) = &r
        {
            render_workspace::assign::assigned(self, value);
        }
        r
    }

    /// What follows a command's run, whether it ran here or on a worker (a save): its echo,
    /// the status line when it failed, what opening and saving update, and the toolbar tab.
    pub(crate) fn finish_command(&mut self, id: &str, r: &Result<Value, String>) {
        let id = solidcraft_engine::find_command(id).map_or(id, |spec| spec.id);
        match r {
            Ok(v) => {
                // Programmatic callers (the control channel, scripts) run outside a render
                // language scope, so resolve the echo from the saved preference instead of the
                // thread-local scope. The command's own label is translated too, so the echo
                // reads the same way the toolbar button it came from does.
                let language = i18n::Locale::for_language(&self.preferences.language);
                let label = language.label(command_label(id));
                // Frames of a gesture (a continuous view move, a part dragged by its joints) are
                // not echoed one by one.
                if v.get("continuous").and_then(Value::as_bool) != Some(true) {
                    self.session.echo(language.format("ui.command_done", &[("command", label)]));
                }
                if id == "file.new" {
                    // `file.new` starts from millimetres. Units of new designs still apply (#1205).
                    prefs::apply_new_design(self);
                }
                if matches!(id, "file.new" | "doc.open" | "doc.recover") {
                    documents::reset_chat(self);
                    self.edit_in_place.active = None;
                    render_workspace::reset_document(self);
                    dim_view::cancel();
                    design_properties::close_object(self);
                    timeline::stop_playback(self);
                    self.menu.props = None;
                    sketch_attachment_ui::clear(self);
                    // The old document is already replaced: discard its editor without
                    // applying cancellation hooks (such as restoring its timeline marker).
                    self.dialog = None;
                    self.applying = None;
                    self.editing_state = None;
                    self.pending_feature_edit = None;
                    self.pre_edit_component = None;
                    // So does what it had computing: none of it may land in the new design.
                    self.cancel_computing();
                    self.tool = None;
                    self.preview.reset();
                    self.cam = Camera::default();
                    self.fit_view();
                    history_folds::load(self);
                    timeline_scope::reset(self);
                }
                if matches!(id, "file.save" | "file.save_as") {
                    history_folds::remember(self);
                }
                if matches!(id, "doc.open" | "file.save" | "file.save_as")
                    && let Some(p) = self.session.path.clone()
                {
                    self.home.add_recent(&p);
                    if matches!(id, "file.save" | "file.save_as") {
                        home::remember_session(&mut self.home, &self.session);
                        // Say where it went, as an export does (#8693).
                        let saved = self.tr("ui.design_saved").replace("{path}", &p);
                        self.set_status(saved, false);
                    }
                }
            }
            Err(e) => {
                // The native menu runs Undo and Redo before `logic` installs the frame scope, so
                // the error would be translated with the thread default.
                let _language = i18n::scope(&self.preferences.language);
                let msg = friendly_error(id, e);
                self.session.echo(msg.clone());
                self.set_status(msg, true);
            }
        }
        if self.session.active_sketch.is_none() && self.ui.tab == "SKETCH" {
            self.tool = None;
        }
        workspace::sync_context(self);
    }

    /// Start the last tool or dialog started again, with its defaults (Repeat in the menus,
    /// the `edit.repeat` command and its key, Shift+R by default; #3045, #7077). `false` when
    /// none was started yet: the status line says so.
    pub fn repeat_last(&mut self) -> bool {
        let Some((id, _)) = self.last_command.clone() else {
            self.set_status(self.tr("ui.repeat_nothing").to_string(), false);
            return false;
        };
        self.start(&id);
        true
    }

    /// Start a command the way a toolbar click does: interactive tools, menus and dialogs for commands
    /// that have them, otherwise run it with defaults.
    pub fn start(&mut self, id: &str) {
        self.start_at(id, None);
    }

    /// A command that started nothing puts the ribbon back on the tab `start` was called from,
    /// the way a disabled command never leaves it (#10540). Only a `start` that moved the tab
    /// has anything to put back.
    pub(crate) fn restore_command_tab(&mut self) {
        if let Some(tab) = self.command_tab_before_start.take() {
            self.ui.tab = tab;
        }
    }

    /// Insert Design's file picker: another design becomes a linked component; a STEP or mesh
    /// file picked here is inserted the way Insert STEP or Insert Mesh would (#1240).
    pub(crate) fn pick_design_to_insert(&mut self) {
        self.pick_open(|app, path| {
            let Some(path) = path else { return };
            if solidcraft_engine::io::is_design_path(&path) {
                // Picked in the file dialog: its server is the user's choice.
                let hosts: Vec<String> = solidcraft_engine::io::vfs::network_host(&path).into_iter().collect();
                let inserted = solidcraft_engine::io::vfs::allowing_hosts(&hosts, || app.run("component.insert_design", json!({ "path": path })));
                if inserted.is_ok() {
                    app.fit_view();
                }
            } else {
                app.insert_path_async(&path);
            }
        });
    }

    /// A command that needs one choice from a short list: its menu under the button that started it
    /// (a second click closes it), or in the middle of the viewport when started without one
    /// (command search, a shortcut, `ui.start`).
    fn open_choice_menu(&mut self, opener: Option<egui::Rect>, target: context_menu::Target) {
        if let Some(rect) = opener {
            context_menu::toggle_for(self, rect, rect.left_bottom(), target);
        } else {
            let at = self.viewport.rect.map(|rect| rect.center()).unwrap_or(egui::pos2(300.0, 200.0));
            context_menu::open_for(self, at, target);
        }
    }

    /// Start an interactive command with its menu anchored below the invoking button.
    pub(crate) fn start_at(&mut self, id: &str, opener: Option<egui::Rect>) {
        self.start_with_variant_memory(id, true, opener, false);
    }

    /// A dedicated toolbar button starts its exact tool without replacing the sketch family's
    /// main button. Choosing a variant from a menu still uses `start` and remembers that choice.
    pub(crate) fn start_pinned(&mut self, id: &str, opener: Option<egui::Rect>) {
        self.start_with_variant_memory(id, false, opener, false);
    }

    /// Existing Section editor uses the normal command-start lifecycle, with explicit edit intent.
    pub(crate) fn start_section_edit(&mut self) {
        self.start_with_variant_memory("inspect.section", true, None, true);
    }

    fn start_with_variant_memory(&mut self, id: &str, remember_variant: bool, opener: Option<egui::Rect>, section_edit: bool) {
        // A tool can be started outside the frame's scope (a direct `start`, a shortcut in
        // `logic`): build its hint in the user's language, not the thread default.
        let _language = crate::i18n::scope(&self.preferences.language);
        if solidcraft_engine::panels::commands::is_command(id) {
            if let Err(why) = self.run(id, json!({})) {
                self.set_status(why, true);
            }
            return;
        }
        self.tree.clear_folder_pick();
        // A command started from the folded ribbon's open panels closes them (#10112).
        self.ui.ribbon_open = false;
        // Folding the ribbon, or showing it whole, keeps the tab it shows (no switch to VIEW).
        if id == "view.ribbon_tabs_only" {
            let _ = self.run(id, json!({}));
            return;
        }
        if id == "timeline.play" {
            if let Err(why) = self.run(id, json!({})) {
                self.set_status(why, true);
            }
            return;
        }
        if id == "ui.assistant" {
            if agent_chat::shown(self) {
                agent_chat::toggle(self);
            }
            return;
        }
        if id == "ui.palette" {
            shortcut_box::open(self, None);
            return;
        }
        timeline::stop_playback(self);
        // A file is loading: the design waits for it.
        if self.file_load.busy() || self.file_picker.is_some() {
            return;
        }
        if id != "occurrence.move" {
            joint_handles::close(self);
        }
        // Repeat Last Command starts the tool it names; it is never the one repeated itself.
        if id == "edit.repeat" {
            self.repeat_last();
            return;
        }
        // Modify ▸ Delete deletes what is selected, as the Delete key does (#9079); with nothing
        // selected it says what to pick instead of running with no features.
        if id == "timeline.delete" {
            if delete::nothing_to_delete(self) && self.tree.picked_timeline_groups.is_empty() {
                self.set_status(self.tr("ui.delete_select_first"), false);
            } else if !timeline_left::delete_selected_folders(self) {
                delete::delete_selection(self);
            }
            return;
        }
        // The Dependents button of INSPECT ▸ HISTORY asks for the dependents of ONE
        // feature, so it needs a target. With nothing selected it used to run the
        // command with no feature and the engine answered "Feature Dependents:
        // `feature` must be an id or name". It reports the dependents of what is
        // selected, one command call per selected feature.
        if id == "timeline.dependents" {
            let selected = timeline::selected_feature_ids(self);
            if selected.is_empty() {
                self.set_status(self.tr("ui.dependents_select_first"), false);
                return;
            }
            for feature_id in selected {
                if let Err(why) = self.run("timeline.dependents", json!({ "feature": feature_id })) {
                    self.set_status(why, true);
                }
            }
            return;
        }
        // Front … Isometric (Ctrl+1…7 by default) turn the view as the view cube's faces do. The
        // flat pattern is a 2D page: it has no other side to turn to.
        if solidcraft_engine::standard_view(id).is_some() {
            if !dialogs_sheet::flat_active(self) {
                // `view.isometric` → "isometric", which `StandardView::parse` reads as Iso.
                self.animate_view(id.trim_start_matches("view."));
                self.home.open = false;
            }
            return;
        }
        // Print Face (Ctrl+B) acts on the selected face at once: it has no dialog.
        if id == "body.print_face" {
            print_face_ui::toggle(self);
            return;
        }
        if id == "view.normal_to" {
            if self.run(id, json!({"camera": self.cam})).is_ok() {
                if self.universal_panel_host_enabled()
                    && let (Some(mut camera), Some(layout), Ok(usable)) =
                        (self.session.camera, self.viewport.layout.as_ref(), shell::host_usable(self))
                {
                    // Match the established follow-view up-axis semantics before
                    // calculating the exact full-domain projection offset.
                    if !render_workspace::active(self) {
                        camera.up = self.cam.up;
                    }
                    let bounds = viewport::selection_bounds(self);
                    let centred = if render_workspace::active(self) {
                        render_workspace::centre_host_product_camera(self, camera, bounds.as_ref(), layout, &usable)
                    } else {
                        viewport_layout::centre_host_camera(camera, bounds.as_ref(), layout, &usable, self.view_fov())
                    };
                    if let Some(centred) = centred {
                        self.session.camera = Some(centred);
                    }
                }
                self.follow_view_request(true);
                self.home.open = false;
            }
            return;
        }
        // A drawing tool on the SKETCH tab kept shown outside a sketch (#7904) starts Create
        // Sketch, on the selected plane or planar face or else on the plane picked next, and then
        // the tool, as the tool's shortcut does outside a sketch (`keymap::press`).
        if workspace::starts_a_sketch(self, id)
            && let Some(then) = solidcraft_engine::find_command(id).map(|c| c.id)
        {
            self.start("sketch.create");
            if let Some(d) = self.dialog.as_mut().filter(|d| matches!(d.kind, dialogs::Kind::Sketch)) {
                d.then_start = Some(then);
            }
            // The ribbon stays on SKETCH while the plane is picked, not on Create Sketch's MODEL.
            self.ui.tab = "SKETCH".into();
            return;
        }
        // A disabled command starts nothing, however it was reached. The toolbar greys its
        // button, but a shortcut, the command palette and the control channel all land here.
        // Its reason goes to the status line, so the refusal is never silent.
        if let Some(info) = solidcraft_engine::find_command(id).map(|c| c.info(&self.session))
            && let Some(why) = info.disabled_reason
        {
            let label = self.tr_label(info.label).to_string();
            let why = self.tr_label(&why).to_string();
            self.set_status(format!("{label}: {why}"), true);
            return;
        }
        if render_workspace::start_interactive(self, id) {
            return;
        }
        // A display toggle leaves the current modelling tool and camera in place, and the ribbon
        // where it is: F6, the navigation bar and the view cube never went through `start`, so
        // command search and the VIEW tab's menus must not move the tab either (#10540).
        if matches!(
            id,
            "view.fit"
                | "view.home"
                | "view.tool.zoom"
                | "view.spin"
                | "view.grid"
                | "view.ground_shadow"
                | "view.navigation_bar"
                | "view.next_tab"
                | "view.previous_tab"
        ) {
            let _ = self.run(id, json!({}));
            return;
        }
        // A display choice opens its choices, as the navigation bar's menus do: run with no
        // parameters it could only fail (#8868); so does the selection filter's mode (#11505). The choices menu is not the command's ribbon
        // place, so the ribbon keeps its tab however the menu was opened (#10540).
        let choice = match id {
            "view.visual_style" => Some(context_menu::Target::VisualStyle),
            "view.tool" => Some(context_menu::Target::ViewTool),
            "select.filter" => Some(context_menu::Target::SelectionFilter),
            _ => None,
        };
        if let Some(target) = choice {
            self.open_choice_menu(opener, target);
            return;
        }
        // The ribbon moves to the command's tab; a command that starts nothing puts it back, so
        // a refusal is answered on the tab the user started from, as a disabled command above
        // already is (#10540).
        self.command_tab_before_start = Some(self.ui.tab.clone());
        workspace::select_command_tab(self, id);
        if id == "occurrence.move" {
            joint_handles::start(self);
            return;
        }
        // One selected placement moves as a component, the same way as its Browser menu,
        // retaining the exact instance path and the grounding/rigid-group restrictions.
        // A selected body, or a component picked in the tree, opens Move/Copy on those bodies.
        if id == "solid.move"
            && let [solidcraft_engine::Sel::Occurrence { path }] = self.session.selection.as_slice()
        {
            let target = context_menu::Target::Occurrence { path: path.clone() };
            if let Some(item) = context_menu::items(self, &target).into_iter().find(|item| item.id == "ui.moveOccurrence") {
                context_menu::run_item(self, &item, egui::Pos2::ZERO);
            }
            return;
        }
        if id == "inspect.colored_components" {
            drop(self.run(id, serde_json::json!({})));
            return;
        }
        if id == "material.properties.validate" {
            self.material_card_review = Some(material_card_review::ReviewWindow::default());
            self.home.open = false;
            return;
        }
        if id == "library.export" {
            dialogs_library::start_export(self);
            return;
        }
        if id == "view.layout" {
            let mode = if self.ui.layout == shell::LayoutMode::Floating { "compact" } else { "floating" };
            let _ = self.run(id, json!({"mode":mode}));
            return;
        }
        if id == "view.render_focus" {
            let _ = self.run(id, json!({"on": !self.shell.render_focus}));
            return;
        }
        if id == "view.render_browser" {
            let _ = self.run(id, json!({"open": !self.shell.render_browser_open}));
            return;
        }
        if id == "view.shots_strip" {
            let _ = self.run(id, json!({"visible": !self.preferences.render_shots_strip}));
            return;
        }
        if id == "view.history_layout" {
            let _ = self.run(id, json!({}));
            return;
        }
        // Profiles are named and picked in Preferences.
        if id.starts_with("settings.profile.") {
            prefs::open_at(self, prefs::PAGE_GENERAL);
            return;
        }
        if id == "view.ambient_occlusion" {
            let _ = self.run(id, json!({"enabled": !self.preferences.ambient_occlusion}));
            return;
        }
        // Send to Slicer always asks which slicer (the dialog pre-selects the last one).
        if matches!(id, "file.send_to_slicer" | "file.open_in_easyprint") && !dialogs_save_mesh::available(self) {
            self.set_status(self.tr("ui.send_to_slicer_unavailable").to_string(), true);
            self.restore_command_tab();
            return;
        }
        if id == "view.perspective" {
            let _ = self.run(id, json!({"enabled": !self.ui.perspective}));
            return;
        }
        if id == "view.angle_readout" {
            let _ = self.run(id, json!({"enabled": !self.preferences.show_view_angles}));
            return;
        }
        // Another command ends Edit Text (its dialog is not a feature edit to keep).
        sketch_text_move::cancel_drag(self);
        if sketch_text::editing(self) || self.dialog.as_ref().is_some_and(|d| matches!(d.kind, dialogs::Kind::TextMove(_))) {
            dialogs::cancel(self);
        }
        // A component moved without Capture Position: ask first (Capture, Revert or Cancel).
        if browser::needs_capture(self, id) && !(id == "sketch.dimension" && self.session.active_sketch.is_some()) {
            self.tree.capture_prompt = Some(id.to_string());
            return;
        }
        // A line-type toggle changes the current drawing, including a partly picked shape.
        // Handle it before cancelling tools or inline dimensions.
        if id == "sketch.construction" {
            sketch_palette::toggle_construction(self);
            return;
        }
        dim_view::cancel();
        self.tool = None;
        self.home.open = false;
        if dialogs_sheet::start_export(self, id) || toolbar::start_export(self, id) {
            return;
        }
        if id == "component.finish_edit" {
            edit_in_place::finish(self);
            return;
        }
        // The picked drawing is placed (position and scale, previewed) before OK adds it.
        if let Some(ext) = id.strip_prefix("sketch.insert_").filter(|e| matches!(*e, "dxf" | "svg")) {
            let command = id.to_string();
            self.pick_open_for(&[ext], move |app, path| {
                if let Some(path) = path {
                    dialogs_insert_drawing::open(app, &command, path);
                }
            });
            return;
        }
        if id == "component.update_links" && self.edit_in_place.active.is_some() {
            // In a part edited in place it also refreshes the assembly around it.
            edit_in_place::refresh(self);
            if self.session.doc.links.is_empty() {
                return;
            }
        }
        if id == "component.update_links" && !self.session.doc.links.is_empty() {
            // Reading the linked designs again takes a while in a large assembly: off the window
            // thread, the overlay naming the one being read (#5329). A link on a network server
            // not allowed yet asks first.
            network_prompt::update_links(self);
            return;
        }
        if id == "component.insert_design" {
            // The designs open in other tabs first, each a click away, then Browse… (#8570).
            if self.preferences.insert_lists_open_designs && !documents::other_designs(self).is_empty() {
                if let Some(rect) = opener {
                    context_menu::toggle_for(self, rect, rect.left_bottom(), context_menu::Target::InsertDesign);
                } else {
                    let at = self.viewport.rect.map(|rect| rect.center()).unwrap_or(egui::pos2(300.0, 200.0));
                    context_menu::open_for(self, at, context_menu::Target::InsertDesign);
                }
            } else {
                self.pick_design_to_insert();
            }
            return;
        }
        if id == "component.relink" {
            linked_source::start_selected(self);
            return;
        }
        if id == "file.insert_mesh" {
            // Insert Mesh is an explicit ask for a mesh: a PLY chosen here is read as one (its
            // faces), after asking its unit, where any other way of inserting it is a point cloud.
            // Like Insert SVG it asks the host for its own kind of file (on the web a file dialog,
            // not the window that also opens and downloads designs), so the file comes straight
            // back here and nothing has to remember which command asked.
            self.pick_open_for(&["3mf", "stl", "obj", "ply", "glb", "gltf"], |app, path| {
                if let Some(path) = path
                    && !mesh_units::ask_ply_as_mesh(app, &path)
                {
                    app.insert_path_async(&path);
                }
            });
            return;
        }
        if matches!(id, "file.insert_step" | "pointcloud.insert") {
            self.pick_open(|app, path| {
                if let Some(path) = path {
                    app.insert_path_async(&path);
                }
            });
            return;
        }
        if !section_edit && !sketch_tools::start_hook(self, id) {
            return;
        }
        if remember_variant && solidcraft_engine::find_command(id).is_some_and(|c| c.info(&self.session).enabled) {
            self.preferences.sketch_variants.remember(id);
        }
        if id == "document.units" {
            if let Some(rect) = opener {
                context_menu::toggle_for(self, rect, rect.left_bottom(), context_menu::Target::Units);
            } else {
                let at = self.viewport.rect.map(|rect| rect.center()).unwrap_or(egui::pos2(300.0, 200.0));
                context_menu::open_for(self, at, context_menu::Target::Units);
            }
            return;
        }
        if id == "parameters.change" {
            params_dialog::open(self);
            return;
        }
        if matches!(id, "document.metadata" | "document.metadata.set") {
            design_properties::open(self);
            return;
        }
        if id == "sketch.inspect" {
            sketch_report::open(self);
            return;
        }
        if id == "assembly.bom" {
            bom_panel::open(self);
            return;
        }
        // Inspect → Measure → Properties: the window, not a reply nobody sees (#8095).
        if matches!(id, "component.properties" | "occurrence.properties") {
            design_properties::open_selected(self);
            return;
        }
        if id == "sketch.edit" {
            self.start_sketch_edit(opener);
            return;
        }
        if id == "sketch.finish" {
            self.finish_sketch();
            return;
        }
        if id == "sketch.cancel" {
            self.cancel_sketch();
            return;
        }
        // Press Pull: edges get a fillet, a fillet's round face or a chamfer's flat one reopens
        // its feature (its size changes, as `solid.press_pull` does: #1932, #4986), other curved
        // faces an offset, planar faces and profiles an extrude.
        if id == "solid.press_pull" {
            if let Some(pending) = &mut self.pending_feature_edit {
                pending.then_start(id);
                return;
            }
            if self.session.selection.iter().any(|s| matches!(s, solidcraft_engine::Sel::Edge { .. })) {
                return self.start("solid.fillet");
            }
            let sel = &self.session.selection;
            let blend = sel.iter().find_map(|s| match s {
                solidcraft_engine::Sel::Face { body, index, point } => dialogs::blend_feature(&self.session, body, *index).map(|id| (id, *point)),
                _ => None,
            });
            // Its arrow sits on the edge of the face clicked.
            if let Some((blend, point)) = blend {
                return self.edit_feature_at(blend, Some(point));
            }
            let curved = sel.iter().any(
                |s| matches!(s, solidcraft_engine::Sel::Face { body, index, .. } if dialogs::planar_face(&self.session, body, *index).is_none()),
            );
            if curved {
                return self.start("solid.offset_face");
            }
            let empty = sel.is_empty();
            self.start("solid.extrude");
            if let Some(d) = &mut self.dialog {
                // Opened by Press Pull, so the dialog says so, whatever was picked (#11705).
                d.press_pull = true;
                if empty && let Some(input) = d.inputs.first_mut() {
                    input.accept |= selection::FACES | selection::EDGES;
                }
            }
            return;
        }
        let interactive = self.interactive(id);
        if interactive && let Some(pending) = &mut self.pending_feature_edit {
            pending.then_start(id);
            return;
        }
        // Cancel before finishing a sketch or waiting for its history marker.
        if interactive && (self.editing_state.is_some() || self.applying.is_some()) {
            dialogs::cancel(self);
        }
        let finished_sketch = self.session.active_sketch.filter(|_| ends_sketch(id) && self.interactive(id));
        // The sketch's end may turn the view (Preferences › Sketch); Extrude goes back to the view
        // it was clicked in, so take that one before the turn starts (#10571).
        self.pre_command_cam = finished_sketch.is_some().then(|| self.settled_cam());
        if finished_sketch.is_some() {
            // A point picked in the sketch being finished stays a pick of that sketch: its
            // placement reads where the sketch puts it once the sketch is no longer the open one.
            if let (Some(sketch), "solid.box" | "solid.sphere" | "solid.torus") = (finished_sketch, id) {
                for sel in self.session.selection.iter_mut() {
                    if let solidcraft_engine::Sel::SketchPoint { id } = sel {
                        *sel = solidcraft_engine::Sel::ExternalSketchPoint { sketch, id: id.clone() };
                    }
                }
            }
            self.finish_sketch();
            // A feature committed before the marker is back would go in where the sketch was.
            if self.deferred.is_some() {
                self.start_after_roll = finished_sketch.map(|sketch| (id.to_string(), sketch));
                // The sketch already took the ribbon back through `sketch_return_tab`; the
                // deferred start must not undo that when it eventually runs (#10540).
                self.command_tab_before_start = None;
                return;
            }
        }
        self.start_interactive(id, finished_sketch);
    }

    /// The rest of [`SolveApp::start`], once any sketch `id` ends is finished.
    pub(crate) fn start_interactive(&mut self, id: &str, finished_sketch: Option<u64>) {
        if let Some(spec) = solidcraft_engine::find_command(id)
            && self.interactive(id)
            && id != "sketch.create"
        {
            self.last_command = Some((spec.id.to_string(), spec.label.to_string()));
        }
        if id == "sketch.project"
            && self.preferences.project_options_dialog
            && let Some(mut d) = dialogs::Dialog::for_command(self, id)
        {
            if let Some(sketch) = finished_sketch {
                d.take_sketch_profile(&self.session, sketch);
            }
            if d.wants_picks() && !self.session.selection.is_empty() {
                let _ = self.session.execute("select.clear", &json!({}));
            }
            self.dialog = Some(d);
            return;
        }
        if let Some(mut t) = tools::Tool::for_command(id) {
            let state = crate::open_meshing::session_world(&self.session);
            let sketch = self.session.active_sketch.and_then(|s| state.sketch(s)).map(|ss| &ss.sketch);
            if let Some(params) = tools::constraint_preselection(id, &self.session.selection, sketch) {
                if self.run(id, params).is_ok() {
                    let _ = self.session.execute("select.clear", &json!({}));
                    self.set_status("Constraint applied", false);
                }
                return;
            }
            if id == "sketch.project"
                && let Some(refs) = tools::projection_preselection(&self.session.selection)
            {
                if self.run(id, json!({"refs":refs})).is_ok() {
                    let _ = self.session.execute("select.clear", &json!({}));
                    self.set_status("Projection applied", false);
                }
                return;
            }
            // Curve-pair constraints can consume an exact preselection. Leave ambiguous
            // selections to the ordinary pick tool; never silently constrain a subset.
            if matches!(
                id,
                "sketch.constraint.parallel"
                    | "sketch.constraint.perpendicular"
                    | "sketch.constraint.equal"
                    | "sketch.constraint.tangent"
                    | "sketch.constraint.concentric"
                    | "sketch.constraint.collinear"
            ) && let [solidcraft_engine::Sel::SketchCurve { id: a, .. }, solidcraft_engine::Sel::SketchCurve { id: b, .. }] =
                self.session.selection.as_slice()
                && a != b
            {
                let params = json!({ "a": a, "b": b });
                if self.run(id, params).is_ok() {
                    let _ = self.session.execute("select.clear", &json!({}));
                    self.set_status("Constraint applied", false);
                }
                return;
            }
            if id == "sketch.dimension" {
                t.picks = self
                    .session
                    .selection
                    .iter()
                    .filter_map(|s| match s {
                        solidcraft_engine::Sel::SketchCurve { id, .. } | solidcraft_engine::Sel::SketchPoint { id } => Some(id.clone()),
                        solidcraft_engine::Sel::Axis { name } => tools::sketch_axis_of(self, name).map(str::to_string),
                        _ => None,
                    })
                    .take(2)
                    .collect();
                let _ = self.session.execute("select.clear", &json!({}));
            }
            self.tool = Some(t);
            self.set_status(tools::hint(id), false);
            return;
        }
        if let Some(mut d) = dialogs::Dialog::for_command(self, id) {
            if let Some(sketch) = finished_sketch {
                d.take_sketch_profile(&self.session, sketch);
            }
            // The pre-selection now belongs to the dialog's inputs.
            if d.wants_picks() && !self.session.selection.is_empty() {
                let _ = self.session.execute("select.clear", &json!({}));
            }
            let extrude = matches!(d.kind, dialogs::Kind::Extrude { .. });
            self.dialog = Some(d);
            if extrude {
                self.turn_for_extrude();
            }
            return;
        }
        // Undo and redo can recompute much of the history: off the window thread when slow.
        if matches!(id, "edit.undo" | "edit.redo") {
            let _ = self.run_heavy(id, json!({}));
            return;
        }
        // Change Part Size with no standard part selected (its dialog had nothing to open on).
        if id == "parts.resize" {
            dialogs_part_size::needs_a_part(self);
            self.restore_command_tab();
            return;
        }
        // The command either runs or starts nothing: a refusal (a missing parameter, nothing to
        // work on) leaves the ribbon on the tab it was started from, as a disabled command does
        // (#10540).
        if self.run(id, json!({})).is_err() {
            self.restore_command_tab();
        }
    }

    /// Does starting `id` open a tool or a dialog?
    fn interactive(&self, id: &str) -> bool {
        tools::Tool::for_command(id).is_some() || dialogs::Dialog::for_command(self, id).is_some()
    }

    /// The ribbon has no sketch argument: use one unambiguous sketch pick, otherwise ask.
    fn start_sketch_edit(&mut self, opener: Option<egui::Rect>) {
        use solidcraft_engine::{Sel, doc::FeatureKind};
        let mut sketches: Vec<u64> = self
            .session
            .selection
            .iter()
            .filter_map(|s| match s {
                Sel::Feature { id } => Some(*id),
                Sel::Profile { sketch, .. } | Sel::ExternalSketchCurve { sketch, .. } | Sel::ExternalSketchPoint { sketch, .. } => Some(*sketch),
                Sel::SketchCurve { sketch, .. } => *sketch,
                _ => None,
            })
            .filter(|id| self.session.doc.feature(*id).is_some_and(|f| matches!(f.kind, FeatureKind::Sketch { .. })))
            .collect();
        sketches.sort_unstable();
        sketches.dedup();
        let sketch = match sketches.as_slice() {
            [id] => Some(*id),
            [] => self.session.active_sketch,
            _ => None,
        };
        if let Some(id) = sketch {
            self.edit_feature(id);
        } else {
            dialogs::cancel(self);
            self.tool = None;
            self.open_choice_menu(opener, context_menu::Target::EditSketch);
        }
    }

    /// Edit a feature: sketches open in sketch mode; other features roll the
    /// timeline back to just before themselves and reopen their dialog, filled in.
    pub fn edit_feature(&mut self, id: u64) {
        self.edit_feature_at(id, None);
    }

    /// [`Self::edit_feature`] from a feature row inside one placement of a component (the
    /// Browser's Features folder): that component is active while the feature is edited, so the
    /// edit happens in its placement, and the one active before comes back when the editor ends
    /// (#12720), as a sketch opened the same way does (#8127). A feature of the design itself, or
    /// of the component already active, is edited as it is.
    pub fn edit_feature_in(&mut self, id: u64, placement: Option<(u64, &[u64])>) {
        let Some((component, path)) = placement.filter(|(_, path)| !path.is_empty()) else {
            self.edit_feature(id);
            return;
        };
        // An editor still open from an earlier double-click ends first, giving back its own
        // component, so the one remembered here is the one the user sees before this click.
        dialogs::cancel(self);
        self.return_from_feature_edit();
        let context = (self.session.active_component, self.session.active_occurrence_path.clone());
        let _ = self.run("component.activate", json!({"component": component, "occurrence": path.last(), "path": path}));
        let opened_in = self.session.active_component;
        let moved = (opened_in, &self.session.active_occurrence_path) != (context.0, &context.1);
        self.pre_edit_component = moved.then_some(PreEditComponent { feature: id, component: context.0, path: context.1, opened_in });
        self.edit_feature(id);
        // Nothing opened (a feature without an editor goes to the command palette): the
        // component comes back at once.
        self.return_from_feature_edit();
    }

    /// Once the editor of the feature a Browser double-click activated a component for has ended,
    /// however it ended (OK, Cancel, another command, a sketch finished), the component active
    /// before the double-click is active again (#12720). Unless another component was activated
    /// meanwhile: that one stays, as after a sketch.
    fn return_from_feature_edit(&mut self) {
        let Some(id) = self.pre_edit_component.as_ref().map(|pre| pre.feature) else { return };
        let open = self.dialog.as_ref().is_some_and(|d| d.editing.is_some_and(|(feature, _)| feature == id))
            || self.pending_feature_edit.as_ref().is_some_and(|pending| pending.feature() == Some(id))
            || self.session.active_sketch == Some(id);
        if open {
            return;
        }
        if let Some(pre) = self.pre_edit_component.take().filter(|pre| pre.opened_in == self.session.active_component) {
            self.restore_component(pre.component, pre.path);
        }
    }

    /// [`Self::edit_feature`] opened from a click at `at` on what the feature made: the dialog's
    /// arrow sits by that point (a fillet's or chamfer's edge nearest it).
    pub(crate) fn edit_feature_at(&mut self, id: u64, at: Option<solidcore_record::Vec3>) {
        use solidcraft_engine::doc::FeatureKind;
        // A non-finite point (over the control channel) keeps the first edge.
        self.edit_anchor_hint = at.filter(|p| p.is_finite()).map(|p| (id, p));
        dialogs::cancel(self);
        let Some(f) = self.session.doc.feature(id) else { return };
        if matches!(f.kind, FeatureKind::Sketch { .. }) {
            self.edit_sketch(id);
            return;
        }
        // Nothing here knows what it holds: it says so, and waits for the build that does.
        if let FeatureKind::NewerFileFeature { raw } = &f.kind {
            let why = raw.why();
            self.set_status(why, true);
            return;
        }
        let Some(idx) = self.session.doc.feature_index(id) else { return };
        let marker = self.finish_sketch_for_edit();
        self.tool = None;
        if self.session.doc.marker != marker {
            self.prepare_feature_edit(id, idx, marker);
            return;
        }
        let original = self.session.scratch();
        if dialogs::roll_marker(self, Some(idx)).is_err() {
            return;
        }
        self.open_feature_edit(id, marker, original);
    }

    /// Undo, Redo and the History bar would change the design under an open feature editor (Edit
    /// Hole, Edit Box, …), whose OK and Cancel then refuse it (#10688). They cancel the editor
    /// first, putting its marker back, as starting another tool does; while it is still opening
    /// they wait for it.
    pub(crate) fn close_editor_for_history(&mut self) -> Result<(), String> {
        if self.pending_feature_edit.is_some() {
            let why = i18n::tr("ui.history_waits_for_editor").to_string();
            self.set_status(why.clone(), true);
            return Err(why);
        }
        if self.editing_state.is_some() || self.dialog.as_ref().is_some_and(|d| d.editing.is_some()) {
            dialogs::cancel(self);
        }
        Ok(())
    }

    fn open_feature_edit(&mut self, id: u64, marker: Option<usize>, original: Session) {
        self.editing_state = Some(dialogs::EditingState { source: self.session.scratch(), original });
        // The id check matters while another feature's reopening is still pending: a later call
        // for a feature id that is gone returns before it drops that pending edit.
        let hint = self.edit_anchor_hint.take().filter(|(f, _)| *f == id).map(|(_, p)| p);
        match dialogs::for_feature(self, id, marker) {
            Some(mut d) => {
                d.anchor_hint = hint;
                if !d.previews() {
                    self.editing_state = None;
                }
                self.dialog = Some(d);
            }
            None => {
                dialogs::restore_editing(self, marker);
                self.sbox.text = format!("timeline.edit {{\"feature\": {id}, \"set\": {{}}}}");
                self.ui.palette_open = true;
            }
        }
    }

    /// Edit a sketch: roll the timeline to just after it (back, so later features don't hide
    /// it, or forward from before it, where it isn't built yet: #2716), turn the camera to face
    /// it, and remember the marker so Finish Sketch puts it back. Editing the sketch that is already open does nothing; editing another one
    /// finishes the current sketch first, so edit sessions never nest.
    pub fn edit_sketch(&mut self, id: u64) {
        self.edit_sketch_in(id, None);
    }

    /// Edit a sketch as [`SolveApp::edit_sketch`] does, in one placement of its component (a
    /// sketch row inside a component in the browser): that component is active while the sketch
    /// is open, and the one active before comes back when the sketch ends (#8127).
    pub fn edit_sketch_in(&mut self, id: u64, placement: Option<(u64, &[u64])>) {
        let activate = |app: &mut Self| {
            if let Some((component, path)) = placement {
                let _ = app.run("component.activate", json!({"component": component, "occurrence": path.last(), "path": path}));
            }
        };
        if let solidcraft_engine::doc::FaceAttachmentStatus::Lost { message, .. } =
            self.session.placed_document().sketch_face_attachment(id, &self.session.model)
        {
            activate(self);
            browser::redefine_sketch(self, id);
            self.set_status(message, true);
            return;
        }
        if self.session.active_sketch == Some(id) {
            return;
        }
        if self.session.doc.feature_index(id).is_none() {
            return;
        }
        let marker = self.finish_sketch_for_edit();
        let before = self.settled_cam();
        let context = (self.session.active_component, self.session.active_occurrence_path.clone());
        self.tool = None;
        self.dialog = None;
        activate(self);
        if self.run("sketch.edit", json!({ "sketch": id, "restore_marker": marker })).is_err() {
            self.restore_component(context.0, context.1);
            return;
        }
        // `sketch.edit` itself activates the component a face-attached sketch was drawn in.
        let opened_in = self.session.active_component;
        let moved = (opened_in, &self.session.active_occurrence_path) != (context.0, &context.1);
        self.pre_sketch_component = moved.then_some(PreSketchComponent { sketch: id, component: context.0, path: context.1, opened_in });
        self.look_at_opened_sketch(before);
    }

    /// Make a component active again, in the placement it was active in.
    fn restore_component(&mut self, component: u64, path: Option<Vec<u64>>) {
        if (self.session.active_component, &self.session.active_occurrence_path) == (component, &path) {
            return;
        }
        let mut p = json!({ "component": component });
        if let Some(path) = path {
            p["occurrence"] = json!(path.last());
            p["path"] = json!(path);
        }
        let _ = self.run("component.activate", p);
    }

    /// Turn the view to face the sketch just opened, unless the "Turn to face a sketch when it
    /// opens" preference is off, and remember the view from `before` it and the one facing it for
    /// when the sketch ends (#7038). Returns whether the view turned.
    pub(crate) fn look_at_opened_sketch(&mut self, before: Camera) -> bool {
        let turn = self.preferences.sketch_open_look_at;
        if turn {
            dialogs::look_at_sketch(self);
        }
        self.pre_sketch_cam = self.session.active_sketch.map(|sketch| PreSketchView { sketch, before, facing: self.settled_cam() });
        turn
    }

    /// Extrude opened: turn the view to isometric when Preferences say so, and remember the view
    /// from before for when the dialog closes (#9176).
    fn turn_for_extrude(&mut self) {
        if !self.preferences.extrude_view_isometric {
            return;
        }
        let before = self.pre_command_cam.take().unwrap_or_else(|| self.settled_cam());
        let mut to = before;
        to.set_view(StandardView::Iso);
        self.pre_extrude_cam = self.preferences.extrude_view_return.then_some(before);
        self.animate_to(to);
    }

    /// Once Extrude has closed, however it closed, the view goes back to where it was before
    /// Extrude turned it (#9176). Going back keeps the projection, as at the end of a sketch.
    fn return_from_extrude_view(&mut self) {
        if self.dialog.as_ref().is_some_and(|d| matches!(d.kind, dialogs::Kind::Extrude { .. })) {
            return;
        }
        if let Some(before) = self.pre_extrude_cam.take() {
            self.animate_to(Camera { fov: self.settled_cam().fov, ..before });
        }
    }

    /// Where the camera is going: the end of the running camera animation, else where it is.
    pub(crate) fn settled_cam(&self) -> Camera {
        self.cam_anim.map_or(self.cam, |a| a.to)
    }

    /// Pass the original marker to the next editor. Restoring it between editors could finish
    /// in the background after the next rollback, moving the marker out from under that edit.
    fn finish_sketch_for_edit(&mut self) -> Option<usize> {
        let marker = self
            .pending_feature_edit
            .take()
            .map(|pending| pending.marker)
            .unwrap_or_else(|| self.session.sketch_restore_marker().unwrap_or(self.session.doc.marker));
        if self.session.active_sketch.is_some() {
            let command = self.take_sketch_exit().unwrap_or_else(|| "sketch.finish".into());
            self.prepare_sketch_exit();
            let _ = self.run(&command, json!({"restore_marker": false}));
        }
        marker
    }

    /// Finish the active sketch: stop editing and restore the history marker Edit Sketch moved.
    /// The camera goes where the "When a sketch ends" preference says (#7038); by default it
    /// stays where it is, however the sketch is left.
    pub fn finish_sketch(&mut self) {
        self.leave_sketch("sketch.finish");
    }

    /// Cancel Sketch (#3838): leave the sketch without its changes. When the command refuses (the
    /// undo history no longer leads back to where the sketch was opened), the sketch stays open.
    pub fn cancel_sketch(&mut self) {
        self.leave_sketch("sketch.cancel");
    }

    fn leave_sketch(&mut self, command: &str) {
        self.prepare_sketch_exit();
        if self.session.sketch_restore_marker().is_some() {
            // Finishing now restores the marker in the engine: evaluate the complete
            // command ahead so rebuilding later features stays off the window thread.
            let _ = self.run_heavy(command, json!({}));
        } else {
            let _ = self.run(command, json!({}));
        }
    }

    fn prepare_sketch_exit(&mut self) {
        sketch_text_move::cancel_drag(self);
        if sketch_text::editing(self) || self.dialog.as_ref().is_some_and(|d| matches!(d.kind, dialogs::Kind::TextMove(_))) {
            dialogs::cancel(self);
        }
        dim_view::cancel();
        self.tool = None;
    }

    /// Successful UI and programmatic exits share the same window cleanup.
    fn sketch_closed(&mut self, open: Option<u64>) {
        self.take_sketch_exit();
        self.tool = None;
        dim_view::cancel();
        // Unless another component was activated meanwhile: that one stays.
        if let Some(pre) = self.pre_sketch_component.take().filter(|pre| Some(pre.sketch) == open && pre.opened_in == self.session.active_component) {
            self.restore_component(pre.component, pre.path);
        }
        // Only the views saved when this sketch opened: one opened another way saved none.
        if let Some(view) = self.pre_sketch_cam.take().filter(|v| Some(v.sketch) == open)
            && let Some(to) = self.preferences.sketch_exit_view.view_after(view.before, view.facing, self.settled_cam())
        {
            self.animate_to(to);
        }
    }

    /// Visibility in the editor's scene: hidden face-profile sources are temporarily shown
    /// without changing the session's visibility or either history stack.
    pub(crate) fn body_visible(&self, name: &str) -> bool {
        self.session.body_visible(name) || self.dialog.as_ref().is_some_and(|d| d.edit_source_bodies.iter().any(|source| source == name))
    }

    /// Everything shown as selected: the selection plus the open dialog's inputs.
    pub fn highlighted(&self) -> Vec<solidcraft_engine::Sel> {
        let mut v = self.session.selection.clone();
        if let Some(d) = &self.dialog {
            v.extend(d.highlighted(&self.session));
        }
        v.extend(sketch_text::highlighted(self));
        v.extend(sketch_text_move::highlighted(self));
        v
    }

    /// Is the browser's Origin folder shown? The design keeps it once it is toggled; until then
    /// the Hide Origin by Default preference decides.
    pub fn origin_shown(&self) -> bool {
        !self.session.visibility.origin_hidden.unwrap_or(self.preferences.hide_origin)
    }

    /// Show or hide the browser's Origin folder (saved with the design).
    pub fn set_origin_shown(&mut self, on: bool) {
        self.session.visibility.origin_hidden = Some(!on);
    }

    /// Is the origin widget shown? Origin planes and axes are drawn and pickable. While a dialog
    /// picks a plane ([`SolveApp::picking_plane`]) the Origin is always shown, drawn through the
    /// model (a plane inside a body stays visible), even when the browser hides it — except the
    /// origin planes for Project ([`SolveApp::picking_project_geometry`], #10778), which keep a
    /// hidden Origin hidden.
    pub fn origin_visible(&self) -> bool {
        self.origin_shown() || self.picking_plane()
    }

    /// Is Create Sketch open, waiting for its plane?
    pub fn picking_sketch_plane(&self) -> bool {
        self.dialog.as_ref().is_some_and(|d| matches!(d.kind, dialogs::Kind::Sketch))
    }

    /// Is a dialog waiting for a plane: Create Sketch, or a dialog whose active input takes origin
    /// planes (Mirror's plane, Offset Plane, Midplane, the construct tools)? The origin planes are
    /// shown for it, so they can be picked in the view rather than only in the browser (#2581).
    pub fn picking_plane(&self) -> bool {
        self.picking_sketch_plane() || self.dialog.as_ref().is_some_and(|d| d.inputs.get(d.active).is_some_and(|i| i.accept & selection::PLANES != 0))
    }

    /// Is the Sketch Project dialog open, picking its geometry? Its pick takes origin planes,
    /// but Project must not bring hidden origin planes back (#10778): every line a plane
    /// projects, an origin axis already gives, so the planes only add noise over the geometry
    /// being picked. Other dialogs that pick a plane keep the reveal ([`Self::picking_plane`],
    /// #2581).
    pub fn picking_project_geometry(&self) -> bool {
        self.dialog.as_ref().is_some_and(|d| matches!(d.kind, dialogs::Kind::SketchProject { .. }))
    }

    /// The field of view the view is drawn with: the `perspective_fov` preference while the view is
    /// in perspective ([`Self::perspective_view`]), and 0 (parallel) otherwise. The one place the
    /// drawn angle is decided.
    pub fn view_fov(&self) -> f64 {
        if self.perspective_view() { prefs::perspective_fov(&self.preferences) } else { 0.0 }
    }

    /// Is the view drawn in perspective? The perspective preference, except while a sketch is
    /// open (always orthographic) or when the #2682 mode is on: then the view is orthographic
    /// exactly when the camera faces a standard axis view, and perspective otherwise.
    pub fn perspective_view(&self) -> bool {
        if self.session.active_sketch.is_some() {
            return false;
        }
        if self.ui.auto_ortho_faces {
            return self.cam.aligned_standard_view(ORTHO_FACE_TOLERANCE).is_none();
        }
        self.ui.perspective
    }

    pub fn set_status(&mut self, s: impl Into<String>, error: bool) {
        let (text, at) = (i18n::tr_diagnostic(&s.into()), now_ms());
        self.messages.push(&text, error, at);
        self.status = Some((text, at, error));
        self.status_undo = false;
    }

    /// Tell the user when the open design came from a newer SolidCraft: the notice on the status
    /// line, and what this version couldn't read in the messages.
    pub(crate) fn say_newer_file(&mut self) {
        let Some(file) = self.session.doc.newer_file.clone() else { return };
        for what in &file.not_understood {
            let text = i18n::format("document.newer_file_not_read", &[("what", what)]);
            self.messages.push(&text, false, now_ms());
        }
        let text = if file.format <= file.reads_up_to && !file.unknown_changes.is_empty() {
            let change = file.unknown_changes.first().map_or("", String::as_str);
            i18n::format("document.newer_file_change", &[("format", &file.format.to_string()), ("change", change)])
        } else {
            i18n::format("document.newer_file", &[("format", &file.format.to_string()), ("reads", &file.reads_up_to.to_string())])
        };
        self.set_status(text, false);
    }

    /// Open the design (or file) at `path` here and now: it is read and evaluated before this
    /// returns, which blocks the thread for a large design. The app opens through
    /// [`Self::open_path_async`] or [`Self::open_path_answered`] (progress and Cancel, #10198);
    /// this is for tests.
    #[cfg(test)]
    pub(crate) fn open_path(&mut self, path: &str) {
        self.open_path_with(path, &Default::default());
    }

    /// Open the design (or file) at `path` here and now, with the import options of the request
    /// (`units` of an STL or OBJ file). The web file loader uses it for its own formats that have
    /// no staged open.
    pub fn open_path_with(&mut self, path: &str, options: &serde_json::Map<String, Value>) {
        match documents::reuse_path(self, path) {
            Ok(true) => return,
            Err(e) => {
                self.set_status(e, true);
                return;
            }
            Ok(false) => {}
        }
        self.home.open = false;
        documents::prepare_open(self);
        let params = self.load_params(path, options);
        if let Ok(r) = self.run("doc.open", params) {
            // An opened design comes up at the home view, not at the angle the design before it
            // was left at: `prepare_open` keeps the camera when it reuses a blank design.
            self.cam.set_view(StandardView::Iso);
            self.fit_view();
            stand_up::offer(self, path, &[], Some(&r));
            self.say_newer_file();
        }
    }

    pub fn open_path_async(&mut self, path: &str) {
        file_load::begin(self, path, false);
    }
    /// Open `path` as [`Self::open_path_async`] does, for a caller that has more to do once the
    /// design is in (the web app's design links, #10198): the receiver gets `{"ok": true, ...}`
    /// when it is, or `{"ok": false, "error"}`; it is dropped unanswered when the load is.
    pub fn open_path_answered(&mut self, path: &str) -> std::sync::mpsc::Receiver<Value> {
        let (tx, rx) = std::sync::mpsc::channel();
        let mut request = file_load::Request::new(path, file_load::Kind::Open);
        request.reply = Some(tx);
        if let Err(e) = file_load::begin_request(self, request) {
            self.set_status(e, true);
        }
        rx
    }
    pub fn insert_path_async(&mut self, path: &str) {
        file_load::begin(self, path, true);
    }

    /// The parameters of opening or inserting `path` here: the path, and for a STEP file whether
    /// it gets a history folder (`file_load::step_folder_option`).
    fn load_params(&self, path: &str, options: &serde_json::Map<String, Value>) -> Value {
        let mut params = options.clone();
        params.insert("path".into(), json!(path));
        file_load::step_folder_option(self, path, &mut params);
        Value::Object(params)
    }

    /// Insert CAD bodies, meshes or sketch drawing geometry into the current design.
    pub fn insert_path(&mut self, path: &str) {
        self.insert_path_with(path, &Default::default(), false);
    }

    /// [`Self::insert_path`] with the import options of the request (`units` of an STL or OBJ file).
    /// `mesh`: insert it as a mesh whatever its extension says (a PLY with faces).
    pub fn insert_path_with(&mut self, path: &str, options: &serde_json::Map<String, Value>, mesh: bool) {
        let cmd = if mesh {
            "file.insert_mesh"
        } else if solidcraft_engine::io::is_point_cloud_path(path) {
            "pointcloud.insert"
        } else {
            file_load::insert_command(path)
        };
        let before: Vec<String> = crate::open_meshing::session_world(&self.session).bodies.iter().map(|b| b.name.clone()).collect();
        let params = self.load_params(path, options);
        if let Ok(r) = self.run(cmd, params) {
            self.fit_view();
            stand_up::offer(self, path, &before, Some(&r));
            if let Some(summary) = timeline::import_status(self, &r) {
                self.set_status(summary, false);
            } else if let Some(w) = r["warnings"].as_array().filter(|w| !w.is_empty()) {
                self.set_status(format!("imported with {} warning(s): {}", w.len(), w.first().and_then(Value::as_str).unwrap_or("")), false);
            }
        }
    }

    /// A dropped CAD, mesh, drawing or point cloud (PLY, XYZ, PTS) file joins a design that has
    /// features or point clouds; otherwise it opens.
    pub fn drop_path(&mut self, path: &str) {
        let import = solidcraft_engine::io::is_step_path(path)
            || solidcraft_engine::io::is_mesh_path(path)
            || solidcraft_engine::io::is_point_cloud_path(path)
            || solidcraft_engine::cmd::drawing_import_command(path).is_some();
        if import && (!self.session.doc.features.is_empty() || !self.session.doc.point_clouds.is_empty()) {
            self.insert_path_async(path);
        } else {
            self.open_path_async(path);
        }
    }

    /// Frame the model at once (programmatic use; the toolbar animates).
    /// Make `up` the world's up axis: the camera turns to the same standard view in that world
    /// (home) and frames the model.
    pub fn set_up_axis(&mut self, up: solidcraft_engine::render::UpAxis) {
        self.ui.up_axis = up;
        self.cam_anim = None;
        self.cam.up = up;
        self.cam.set_view(StandardView::Iso);
        self.fit_view();
    }

    /// How many frames a fit waits for a viewport that can frame it before it gives up (about
    /// two seconds): a window that never draws its viewport must not ask for frames forever.
    const FIT_WAITS: u32 = 120;

    pub fn fit_view(&mut self) {
        if render_workspace::result_active(self) {
            render_workspace::fit_result(self);
            return;
        }
        if dialogs_sheet::flat_active(self) {
            self.flat_view.fitted = false;
            return;
        }
        if render_workspace::active(self) {
            self.cancel_view_animation();
            match solidcraft_engine::product_scene::extract(&self.session) {
                Ok(scene) if !scene.bounds.is_empty() => self.fit_bounds(scene.bounds),
                Err(e) => self.set_status(e.to_string(), true),
                _ => {}
            }
            return;
        }
        self.cam_anim = None;
        self.viewport.orbit_free = None;
        let bounds = viewport::view_bounds(self);
        // Framed as the Home button frames: with the navigators' Fit on, that is their shared
        // zoom and centre, so a design opens the way Home shows it (#10091).
        let shared = self.preferences.navigator_fit;
        self.pending_fit = Some((self.cam, bounds, false, shared));
        self.fit_waits = 0;
        self.cam = if shared { self.navigator_fitted(self.cam) } else { self.fitted(self.cam) };
    }

    /// Frame `bounds` at once, keeping the view direction (programmatic use).
    pub fn fit_bounds(&mut self, bounds: solidcraft_engine::geom::Aabb3) {
        self.cancel_view_animation();
        self.viewport.orbit_free = None;
        self.pending_fit = Some((self.cam, bounds, false, false));
        self.fit_waits = 0;
        self.cam = self.fitted_bounds(self.cam, &bounds);
    }

    /// `cam` moved to frame the whole model.
    pub fn fitted(&self, mut cam: Camera) -> Camera {
        let b = viewport::view_bounds(self);
        if b.is_empty() {
            cam.target = solidcore_record::Vec3::ZERO;
            cam.distance = 150.0;
        } else {
            cam = self.fitted_bounds(cam, &b);
        }
        cam
    }

    /// `cam` framing `bounds` in the viewport as it is laid out now, or `None` when this layout
    /// can't frame it: the viewport has not been drawn since the fit was asked for, so the
    /// rectangle to frame into is the one from before the Home screen or a dialog covered it.
    fn try_fitted_bounds(&self, cam: Camera, bounds: &solidcraft_engine::geom::Aabb3) -> Option<Camera> {
        let layout = self.viewport.layout.as_ref()?;
        if self.universal_panel_frame().is_some() {
            let usable = shell::host_usable(self).ok()?;
            if render_workspace::active(self) {
                return render_workspace::fit_host_product_bounds(self, cam, bounds, layout, &usable);
            }
            return viewport_layout::fit_host_bounds(cam, bounds, layout, &usable, self.view_fov(), f64::from(self.preferences.home_fit_size));
        }
        if render_workspace::active(self) {
            return viewport_layout::fit_product_bounds(cam, bounds, &render_workspace::picture_layout(self, layout));
        }
        viewport_layout::fit_bounds_sized(cam, bounds, layout, self.view_fov(), f64::from(self.preferences.home_fit_size))
    }

    /// `cam` framing the whole model the navigators' way (#10091): looking at the middle of the
    /// model from the distance that fits its bounding sphere in the free part of the view, at
    /// the Fit size. The sphere looks the same from every side, so Home and every face,
    /// corner, arrow or axis clicked after it keep one zoom and one centre; only the direction
    /// changes.
    fn navigator_fitted(&self, cam: Camera) -> Camera {
        let bounds = viewport::view_bounds(self);
        self.navigator_fitted_bounds(cam, &bounds).unwrap_or_else(|| self.fitted(cam))
    }

    /// [`Self::navigator_fitted`] for `bounds`, or `None` when the layout can't frame it yet.
    fn navigator_fitted_bounds(&self, mut cam: Camera, bounds: &solidcraft_engine::geom::Aabb3) -> Option<Camera> {
        use solidcraft_engine::geom::Vec3Geom as _;

        if bounds.is_empty() || !bounds.min.is_finite() || !bounds.max.is_finite() {
            return None;
        }
        let centre = bounds.center();
        let radius = (bounds.diagonal() * 0.5).max(0.5);
        // A cube around the sphere, seen square-on from any axis, projects to the sphere's own
        // square, so the layout fit of that cube is the sphere's.
        let offset = solidcore_record::Vec3::new(radius, radius, radius);
        let sphere = solidcraft_engine::geom::Aabb3 { min: centre - offset, max: centre + offset };
        // Keep Classic's original probe; the opt-in host retains the authored lens and up axis.
        let mut probe = if self.universal_panel_host_enabled() { cam } else { Camera::default() };
        probe.set_view(StandardView::Front);
        let framed = self.try_fitted_bounds(probe, &sphere)?;
        cam.target = centre;
        cam.distance = framed.distance;
        if self.universal_panel_frame().is_some() {
            // Carry the sphere's one screen centre into the requested basis too.
            // Recentring its cube in each direction would choose different footprints.
            let offset = framed.target - centre;
            let (front_right, front_up, _) = framed.basis();
            let (right, up, _) = cam.basis();
            cam.target = centre + right * offset.dot(front_right) + up * offset.dot(front_up);
        }
        cam.is_valid().then_some(cam)
    }

    fn fitted_bounds(&self, mut cam: Camera, bounds: &solidcraft_engine::geom::Aabb3) -> Camera {
        if self.viewport.layout.is_some() {
            return self.try_fitted_bounds(cam, bounds).unwrap_or(cam);
        }
        // Framed at the angle the view draws with, keeping the camera's own.
        let previous = cam;
        cam.fov = self.view_fov();
        cam.fit(bounds);
        cam.fov = previous.fov;
        if cam.is_valid() { cam } else { previous }
    }

    fn resolve_fit(&mut self, ctx: &egui::Context) {
        viewport::refresh_layout(self, ctx);
        if self.fit_waits < Self::FIT_WAITS && render_workspace::wait_entry_fit_layout(self) {
            self.fit_waits += 1;
            ctx.request_repaint();
            return;
        }
        if self.viewport.layout.is_some()
            && let Some((cam, bounds, animate, shared)) = self.pending_fit.take()
        {
            // Nothing to frame: the camera goes to the empty design's own distance.
            let want = if bounds.is_empty() { viewport::view_bounds(self) } else { bounds };
            let to = if want.is_empty() {
                Some(self.fitted(cam))
            } else if shared {
                self.navigator_fitted_bounds(cam, &want)
            } else {
                self.try_fitted_bounds(cam, &want)
            };
            let Some(to) = to else {
                // The viewport hasn't been drawn since the fit was asked for (the Home screen was
                // over it, as when a sample or a file is opened from it), so framing it now would
                // frame it into the rectangle of whatever was there before and leave the design
                // wherever the camera happened to be. Keep the request and frame it when the
                // viewport is drawn; give up only if that never comes.
                if self.fit_waits < Self::FIT_WAITS {
                    self.fit_waits += 1;
                    self.pending_fit = Some((cam, bounds, animate, shared));
                } else {
                    self.fit_waits = 0;
                    let previous = self.cam;
                    self.cam = self.fitted_bounds(cam, &want);
                    render_workspace::settle_entry_fit(self, cam, bounds, previous);
                }
                ctx.request_repaint();
                return;
            };
            self.fit_waits = 0;
            if animate {
                self.animate_to(to);
            } else {
                let previous = self.cam;
                self.cam = to;
                self.cam_anim = None;
                render_workspace::settle_entry_fit(self, cam, bounds, previous);
                // An open's framing settles here, once the layout is known. An open still meshing
                // takes this as the camera it framed from the outlines, so the framing it does
                // when the last body is ready isn't mistaken for the user having moved the view.
                open_meshing::note_framed(self);
            }
            ctx.request_repaint();
        }
    }

    /// Move the camera to `to` over half a second (ease in-out, orientation slerped).
    pub fn animate_to(&mut self, to: Camera) {
        self.pending_fit = None;
        self.viewport.orbit_free = None;
        if !to.is_valid() {
            return;
        }
        // Preferences › Navigation: animated (at a chosen speed) or immediate.
        if !self.preferences.look_at_anim {
            self.cam = to;
            self.cam_anim = None;
            return;
        }
        let mut anim = CameraAnim::new(self.cam, to, self.now);
        let speed = f64::from(self.preferences.look_at_speed);
        if speed.is_finite() && speed > 0.0 {
            anim.duration /= speed;
        }
        self.cam_anim = Some(anim);
    }

    /// Frame everything shown, keeping the orientation (animated; the selection is ignored).
    pub fn animate_fit_all(&mut self) {
        if dialogs_sheet::flat_active(self) {
            self.animate_view("fit");
            return;
        }
        if render_workspace::active(self) {
            // The Render preview frames its product scene (see `fit_view`).
            self.fit_view();
            return;
        }
        self.pending_fit = None;
        let request = Some((self.cam, viewport::view_bounds(self), true, false));
        let to = self.fitted(self.cam);
        self.animate_to(to);
        self.pending_fit = request;
    }

    /// Move to `to` and frame the whole model from there at Home's zoom (animated): the
    /// navigators' Home, faces, corners, arrows and axes (`navigator_fitted`).
    pub fn animate_to_fitted(&mut self, to: Camera) {
        let Ok(bounds) = solidcraft_engine::view::bounds(&self.session) else { return };
        let shared = self.preferences.navigator_fit;
        let framed = if shared { self.navigator_fitted(to) } else { self.fitted(to) };
        self.animate_to(framed);
        self.pending_fit = Some((to, bounds, true, shared));
    }

    /// A view chosen on a navigator (a cube face, corner or arrow, an axis tip): the view turns
    /// in place, or frames the whole model from the new direction when Preferences › Navigation
    /// asks for it (`navigator_fit`, #10091).
    pub fn animate_turn(&mut self, to: Camera) {
        if self.preferences.navigator_fit {
            self.animate_to_fitted(to);
        } else {
            self.animate_to(to);
        }
    }

    /// Animated view changes for the axis view and navigation bar.
    pub fn animate_view(&mut self, v: &str) {
        if matches!(v, "fit" | "home") {
            let _ = self.run(if v == "fit" { "view.fit" } else { "view.home" }, json!({}));
        } else if let Some(view) = StandardView::parse(v) {
            self.pending_fit = None;
            let mut to = self.cam;
            to.set_view(view);
            self.animate_to(to);
        }
    }

    /// Apply view.fit / view.home to the active canvas, retaining each canvas's framing policy.
    fn frame_view(&mut self, home: bool) {
        if render_workspace::result_active(self) {
            render_workspace::fit_result(self);
            return;
        }
        // The flat pattern is a 2D view: Fit and Home frame it, and the Design camera stays put.
        if dialogs_sheet::flat_active(self) {
            self.flat_view.fitted = false;
            return;
        }
        if render_workspace::active(self) {
            if home {
                self.cam.set_view(StandardView::Iso);
            }
            self.fit_view();
            return;
        }
        self.pending_fit = None;
        let mut to = self.cam;
        if home {
            to.set_view(StandardView::Iso);
            // With the navigators' Fit on, Home shares their zoom, so a face clicked after it
            // keeps the zoom (#10091).
            let shared = self.preferences.navigator_fit;
            self.pending_fit = Some((to, viewport::view_bounds(self), true, shared));
            to = if shared { self.navigator_fitted(to) } else { self.fitted(to) };
        } else {
            // With something selected, Fit frames the selection.
            match viewport::selection_bounds(self) {
                Some(bounds) => {
                    self.pending_fit = Some((to, bounds, true, false));
                    to = self.fitted_bounds(to, &bounds);
                }
                None => {
                    self.pending_fit = Some((to, viewport::view_bounds(self), true, false));
                    to = self.fitted(to);
                }
            }
        }
        let request = self.pending_fit.take();
        self.animate_to(to);
        self.pending_fit = request;
    }

    /// Frame `bounds` as Fit frames the selection, leaving the selection as it is.
    pub(crate) fn frame_bounds(&mut self, bounds: solidcraft_engine::geom::Aabb3) {
        let from = self.cam;
        let to = self.fitted_bounds(from, &bounds);
        self.pending_fit = None;
        self.animate_to(to);
        self.pending_fit = Some((from, bounds, true, false));
    }

    /// Move the viewport to the camera a command asked for (`view.apply`): animated like a view
    /// change, or at once (control requests, so a screenshot right after shows it).
    pub fn follow_view_request(&mut self, animate: bool) {
        let Some(mut to) = self.session.camera.take() else { return };
        if render_workspace::active(self) {
            self.ui.up_axis = to.up;
        } else {
            to.up = self.cam.up;
        }
        if animate {
            self.animate_to(to);
        } else if to.is_valid() {
            self.cancel_view_animation();
            self.viewport.orbit_free = None;
            self.cam = to;
        }
    }

    /// Stop any view animation where it is (the user took over the camera).
    pub fn cancel_view_animation(&mut self) {
        render_workspace::cancel_entry_fit(self);
        self.pending_fit = None;
        self.cam_anim = None;
    }

    /// Is the 3D view dark? As the window, unless Preferences give the view its own (#4146).
    pub fn viewport_dark(&self) -> bool {
        self.preferences.viewport_theme.dark().unwrap_or(self.ui.dark)
    }

    /// Hand the view to an external navigation device without a pending mouse orbit or spin
    /// immediately taking it back on the next frame.
    pub fn begin_external_navigation(&mut self) {
        self.cancel_view_animation();
        self.viewport.orbit_free = None;
        self.viewport.spin = false;
    }

    fn step_view_animation(&mut self, ctx: &egui::Context) {
        let Some(anim) = self.cam_anim else { return };
        let (cam, done) = anim.sample(self.now);
        self.cam = if cam.is_valid() { cam } else { anim.to };
        if done {
            self.cam_anim = None;
        } else {
            ctx.request_repaint();
        }
    }

    /// Per-frame logic before layout.
    pub fn logic(&mut self, ctx: &egui::Context) {
        // Shortcuts run here, before `ui` installs the language scope: a tool started by its
        // key must build its translated hint in the user's language, not in English.
        let _language = crate::i18n::scope(&self.preferences.language);
        panel_runtime::tick_app(self, ctx);
        // Sleep/wake often skips frames without a device-lost signal; refresh egui GPU textures
        // when the frame clock jumps so the chrome is not stuck blank (#8749).
        let frame_time = ctx.input(|i| i.time);
        if resume_ui::is_long_pause(self.now, frame_time) {
            resume_ui::after_long_pause(ctx);
        }
        frame_watch::begin(self);
        refused_part::next_frame(self, ctx);
        gpu::tick_tessellation(self);
        file_picker::tick(self, ctx);
        dialogs_save_mesh::tick_wait(self, ctx);
        easyprint_ui::tick(self, ctx);
        render_workspace::sync_backend(self);
        render_workspace::tick(self, ctx);
        file_load::tick(self, ctx);
        save_job::tick(self, false);
        edit_in_place::tick(self);
        let typing = ctx.egui_wants_keyboard_input();
        if ctx.input(|i| i.pointer.button_clicked(egui::PointerButton::Extra1) || (i.key_pressed(egui::Key::BrowserBack) && !typing)) {
            edit_in_place::back(self);
        }
        if self.saving.is_some() || self.edit_in_place.refreshing() {
            ctx.request_repaint_after(std::time::Duration::from_millis(16));
        }
        open_meshing::tick(self, ctx);
        open_meshing::refresh(self, ctx.input(|i| i.time));
        // Routing survives a layout re-pass, but never the next input frame. The legacy
        // policy retains its original per-pass cancellation flag behavior.
        let first_pass = ctx.current_pass_index() == 0;
        if first_pass {
            self.escape_owner = None;
        }
        if first_pass || !crate::viewport_status::enabled(self) {
            self.esc_handled = false;
        }
        prefs::apply(self, ctx);
        // The view's own dark or light only changes tokens, not egui's visuals: no restyle.
        theme::set_viewport_dark(self.preferences.viewport_theme.dark());
        theme::set_viewport_background(self.preferences.viewport_background);
        if !self.styled || theme::is_dark() != self.ui.dark || theme::vision() != self.preferences.color_vision {
            theme::set_dark(self.ui.dark);
            theme::set_vision(self.preferences.color_vision);
            theme::apply(ctx);
            self.styled = true;
        }
        theme::TabAccent::publish(self, ctx);
        if !self.fitted {
            self.fit_view();
            self.fitted = true;
        }
        self.now = ctx.input(|i| i.time);
        if self.cam.up != self.ui.up_axis {
            self.set_up_axis(self.ui.up_axis);
        }
        self.step_view_animation(ctx);
        self.poll_control_jobs(ctx);
        self.drain_control(ctx);
        self.follow_view_request(true);
        self.return_from_extrude_view();
        self.return_from_feature_edit();
        agent_cursor::step(self, ctx);
        browser::eye_drag_frame(self, ctx);
        if !self.synthetic.is_empty() || !self.held_click.is_empty() {
            ctx.request_repaint();
        }
        issue_report::tick(self, ctx);
        self.collect_screenshots(ctx);
        self.issue_screenshots(ctx);
        if self.issue_report.draft.is_none() && self.file_picker.is_none() {
            // Completion owns its keys before either CAD shortcuts or text editors see them.
            panel_runtime::reserve_host_input(self, ctx);
            if !keymap::capturing(self) {
                expression_complete::begin_frame(ctx);
            }
            agent_chat::toggle_shortcut(self, ctx);
            // A digit for a construction line's Length box is not a shortcut (#10258).
            sketch_construction::claim_typed_length(self, ctx);
            if !self.embedded {
                toolbar::shortcuts(self, ctx);
            }
        }
        recovery_ui::tick(self);
        open_elsewhere::tick(self, ctx);
        update::tick(self, ctx);
        if self.issue_report.draft.is_none() && self.file_picker.is_none() {
            // Files dropped on the theme Import tile are themes (#8226).
            prefs::take_theme_drops(self, ctx);
            // Files dropped on the agent chat attach to its next message instead.
            agent_chat::take_drops(self, ctx);
            for f in ctx.input(|i| i.raw.dropped_files.clone()) {
                let p = f.path().to_string_lossy().to_string();
                if !p.is_empty() {
                    self.drop_path(&p);
                }
            }
        }
        control::publish_design(self, &control::DESIGN_WATCH);
    }

    /// The frame's input before the app reads it: synthetic events, then what is typed while a
    /// capture hides the report waits for it (the control channel's typing too).
    pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) {
        self.synthetic_input(raw);
        finite_input(raw);
        self.hold_click_after_typing(raw);
        issue_report::hold_input(self, raw);
    }

    /// A pointer button after typing in the same frame (a slow frame) waits for the next frame,
    /// with the events after it. egui 0.37 drops a field's focus on a click elsewhere before the
    /// field reads the frame's typing, which lost what was typed. Drop once emilk/egui#8763 is fixed.
    fn hold_click_after_typing(&mut self, raw: &mut egui::RawInput) {
        if !self.held_click.is_empty() {
            let mut events = std::mem::take(&mut self.held_click);
            events.append(&mut raw.events);
            raw.events = events;
        }
        let button = raw.events.iter().position(|e| matches!(e, egui::Event::PointerButton { .. }));
        if let Some(i) = button
            && raw.events[..i].iter().any(issue_report::typing)
        {
            self.held_click = raw.events.split_off(i);
        }
    }

    /// Inject synthetic events (one pointer event per frame).
    fn synthetic_input(&mut self, raw: &mut egui::RawInput) {
        if self.synthetic.is_empty() {
            return;
        }
        // Text and modifier prefixes may precede a pointer event. Never drain past that event.
        let n = self
            .synthetic
            .iter()
            .position(|e| {
                matches!(
                    e,
                    egui::Event::PointerMoved(_)
                        | egui::Event::PointerButton { .. }
                        | egui::Event::PointerGone
                        | egui::Event::MouseWheel { .. }
                        | egui::Event::Key { pressed: false, .. }
                )
            })
            .map_or(self.synthetic.len(), |i| i + 1);
        let follow = self.ui.agent_cursor.show;
        for event in self.synthetic.drain(..n) {
            // The agent cursor shows the agent's own pointer input too, not only its commands.
            match &event {
                egui::Event::PointerMoved(at) if follow => self.agent.follow_input(*at, false, self.now),
                egui::Event::PointerButton { pos, pressed, .. } if follow => self.agent.follow_input(*pos, *pressed, self.now),
                _ => {}
            }
            match &event {
                egui::Event::ModifiersChanged(modifiers) => self.synthetic_mods = *modifiers,
                egui::Event::PointerButton { pos, modifiers, pressed, .. } => {
                    raw.events.push(egui::Event::PointerMoved(*pos));
                    raw.events.push(egui::Event::ModifiersChanged(*modifiers));
                    // A drag keeps its press's modifiers until the release.
                    self.synthetic_mods = if *pressed { *modifiers } else { egui::Modifiers::NONE };
                    self.synthetic_press = *pressed;
                }
                egui::Event::Key { modifiers, .. } => raw.events.push(egui::Event::ModifiersChanged(*modifiers)),
                egui::Event::PointerMoved(_) => raw.events.push(egui::Event::ModifiersChanged(self.synthetic_mods)),
                _ => {}
            }
            raw.events.push(event);
        }
    }

    /// Lay out the whole window.
    pub fn ui(&mut self, ui: &mut egui::Ui) {
        prefs::prepare_blur(self, ui.ctx());
        render_workspace::displayed::begin(self);
        let blur_source = !self.home.open && !render_workspace::result_active(self);
        let _blur_scope = self.blur.begin(ui.ctx(), blur_source);
        value_step::set_enabled(ui.ctx(), self.preferences.step_values);
        canvas::set_boxes_shown(ui.ctx(), self.preferences.value_boxes_in_view);
        recent_colors::share(ui.ctx(), &mut self.ui.recent_colors);
        let t0 = now_ms();
        // The first frames draw with the bundled faces while the system's CJK, Hangul and Thai
        // faces are read on a thread; the fonts are installed again once they are there.
        crate::fonts::load_system_fonts_in_background(ui.ctx());
        let system_fonts = crate::fonts::system_fonts_ready();
        if self.preferences.language != self.applied_fonts_language
            || self.preferences.ui_font != self.applied_ui_font
            || (system_fonts && !self.applied_system_fonts)
        {
            self.applied_fonts_language.clone_from(&self.preferences.language);
            self.applied_ui_font.clone_from(&self.preferences.ui_font);
            self.applied_system_fonts = system_fonts;
            crate::fonts::setup_fonts_without_waiting(
                ui.ctx(),
                crate::i18n::effective_language(&self.preferences.language),
                &self.preferences.ui_font,
            );
        }
        let _language = crate::i18n::scope(&self.preferences.language);
        let mut report_input = None;
        issue_report::CadInput::block(self, ui, &mut report_input);
        semantic_content::begin(self, ui.ctx());
        self.cad_ui(ui, &mut report_input);
        semantic_content::finalize(self, ui.ctx());
        drop(report_input);
        // After everything else, on every page (the start page too, which returns early from
        // `cad_ui`): the window's edges resize it (#1381).
        if self.custom_titlebar && !self.native_resize_border {
            titlebar::resize_zones(ui);
        }
        if self.file_picker.is_none() {
            issue_report::show(self, ui.ctx());
        }
        if !self.home.open {
            agent_cursor::paint(self, ui.ctx());
        }
        if self.file_picker_busy() {
            ui.ctx().request_repaint_after(std::time::Duration::from_millis(50));
        }
        control::publish_design(self, &control::DESIGN_WATCH);
        self.frame_ms = now_ms() - t0;
        frame_watch::end(self);
        render_workspace::displayed::finish(self, ui.ctx());
    }

    fn cad_ui(&mut self, ui: &mut egui::Ui, report_input: &mut Option<issue_report::CadInput>) {
        if self.embedded {
            self.ui.layout = shell::LayoutMode::Docked;
            self.home.open = false;
            self.ui.show_browser = true;
            self.ui.show_timeline = true;
        }
        if self.embed_editor {
            // The host shows one design and has its own way to start one.
            self.ui.layout = shell::LayoutMode::Docked;
            self.home.open = false;
        }
        self.ui.layout.publish(ui.ctx());
        self.preferences.dialog_buttons.publish(ui.ctx());
        self.preferences.toast_place.publish(ui.ctx());
        scenario::clear_handles();
        self.poll_feature_edit(ui.ctx());
        self.poll_deferred(ui.ctx());
        self.poll_delete_check(ui.ctx());
        timeline::tick_playback(self, ui.ctx());
        if !self.embedded && !self.embed_editor {
            toolbar::app_bar(self, ui);
        }
        issue_report::CadInput::block(self, ui, report_input);
        file_load::show(self, ui.ctx());
        open_meshing::show(self, ui.ctx());
        documents::prompt(self, ui.ctx());
        open_elsewhere::show(self, ui.ctx());
        network_prompt::show(self, ui.ctx());
        update::show(self, ui.ctx());
        install::show(self, ui.ctx());
        // Settings › AI's Add agent dialog: Settings opens over Home too (#3483).
        if agent_chat::shown(self) {
            agent_chat::settings::dialog(self, ui.ctx());
        }
        if self.home.open {
            panel_runtime::hide_app_host(self);
            home::show(self, ui);
            if self.home.open {
                // Agent detection runs in the background and is only received by `agent_chat::poll`
                // Polling here is required for the detection to complete on Home
                agent_chat::poll(self, ui.ctx());
                // Preferences and Keyboard Shortcuts open from Home too (its links, the gear, Ctrl+,).
                prefs::show(self, ui.ctx());
                browser::editors(self, ui);
                return;
            }
        }
        // The status bar first: it spans the window's width below History and the side panels.
        if self.universal_panel_host_enabled() {
            self.universal_workspace_ui(ui);
            semantic_content::finalize(self, ui.ctx());
            // Browser-owned editors retain their independent legacy windows,
            // drafts and capture questions while the Browser host is suppressed.
            browser::editors(self, ui);
        } else {
            status_bar::show(self, ui);
            let floating = render_workspace::active(self) || ui_kit::Container::new(ui.ctx(), ui_kit::Surface::Panel).floating();
            timeline::follow_view_pick(self);
            render_ui::focus_shortcut(self, ui);
            let show_timeline = self.ui.show_timeline && !render_workspace::active(self) && !self.preferences.history_in_browser;
            let left_timeline = show_timeline && self.preferences.timeline_left;
            timeline_left::animate_folds(self, ui.ctx());
            if !floating && !self.embedded {
                toolbar::toolbar(self, ui);
            }
            theme::TabAccent::publish(self, ui.ctx());
            browser::publish_row_prefs(self, ui.ctx());
            if !floating {
                agent_chat::show(self, ui);
            }
            if !floating && show_timeline && !left_timeline {
                timeline::timeline(self, ui);
            }
            // Browser hugs its contents in either layout; it never becomes a full-height blank column.
            if !self.ui.show_browser || render_ui::focused(self) {
                self.shell.browser = None;
                shell::register_panel(self, "render:browser", None, None);
                shell::register_panel(self, "render:appearances", None, None);
            }
            if floating || left_timeline || !show_timeline {
                self.shell.history = None;
            }
            // The model draws next: a dialog the toolbar closed last frame no longer shows its sketch.
            dialogs::sync_feature_edit(self);
            let full = ui.available_rect_before_wrap();
            if floating {
                let cards = toolbar::shell_cards(self, full);
                self.shell.cards = vec![cards.workspace, cards.ribbon];
                self.shell.history = if left_timeline {
                    let below_ribbon = egui::Rect::from_min_max(egui::pos2(full.left(), cards.bottom), full.max);
                    // A dialog in the left column holds the History's place.
                    (!dialog_column::holds(self)).then(|| timeline_left::floating_rect(self, below_ribbon))
                } else {
                    show_timeline.then(|| timeline::floating_rect(full))
                };
                // Draw the scene first, then let the unchanged panel layouts cover it. The
                // viewport keeps its full projection even underneath the browser and cards.
                preview::update(self, ui.ctx());
                // A camera drag that began on the model keeps capture across cards. New
                // gestures over chrome are blocked, as are selection drags into the ribbon.
                let continuing_navigation = ui.input(|i| {
                    (i.pointer.middle_down() || i.pointer.secondary_down())
                        && i.pointer.press_origin().is_some_and(|p| full.contains(p) && !shell::covered(self, p))
                });
                // A captured comparison divider also keeps its primary drag across floating cards.
                let continuing_comparison = render_workspace::comparison_drag_captured(self) && ui.input(|i| i.pointer.primary_down());
                let blocked =
                    !continuing_navigation && !continuing_comparison && ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| shell::covered(self, p));
                let mut viewport_ui = ui.new_child(egui::UiBuilder::new().max_rect(full).id_salt("floating_viewport"));
                if blocked {
                    // Disabled only to shield the scene from input under a card or menu; it must
                    // not fade, or the whole viewport dims whenever the pointer is over the shell.
                    viewport_ui.visuals_mut().disabled_alpha = 1.0;
                    viewport_ui.disable();
                }
                self.show_workspace(&mut viewport_ui);
                shell::paint_top_corners(ui.painter(), full, theme::Tokens::get().app_bar);
                toolbar::toolbar(self, ui);
                theme::TabAccent::publish(self, ui.ctx());
            }
            if floating && show_timeline && !left_timeline {
                timeline::timeline(self, ui);
            }
            dialog_column::layout(self, ui.available_rect_before_wrap());
            if left_timeline {
                timeline_left::left_panel(self, ui);
            }
            if render_workspace::active(self) {
                render_ui::shots_strip(self, ui);
                render_workspace::panel(self, ui);
            }
            if self.ui.show_browser && !render_ui::focused(self) {
                browser::browser(self, ui);
            }
            // Apply shared Browser/History output before viewport and menu consumers.
            semantic_content::finalize(self, ui.ctx());
            browser::editors(self, ui);
            if floating {
                agent_chat::show(self, ui);
            }
            Container::new(ui.ctx(), Surface::Viewport)
                .central()
                .frame(Container::new(ui.ctx(), Surface::Viewport).edge_frame(egui::Color32::TRANSPARENT))
                .show(ui, |ui| {
                    let panel_content = ui.max_rect();
                    self.shell.content = Some(shell::workspace_content(self, panel_content));
                    if floating {
                        self.shell.panels = [
                            egui::Rect::from_min_max(egui::pos2(full.left(), panel_content.top()), egui::pos2(panel_content.left(), full.bottom())),
                            egui::Rect::from_min_max(egui::pos2(panel_content.right(), panel_content.top()), full.max),
                        ]
                        .into_iter()
                        .filter(|r| r.is_positive())
                        .collect();
                        viewport::refresh_layout(self, ui.ctx());
                    } else {
                        preview::update(self, ui.ctx());
                        self.show_workspace(ui);
                    }
                });
        }
        if render_workspace::active(self) {
            render_ui::overlays(self, ui);
        }
        // Measure current persistent sketch chrome before the host's early
        // confirmation pair. Its answer still precedes this frame's dialog.
        if self.universal_panel_host_enabled() {
            sketch_palette::show(self, ui.ctx());
            self.viewport.host_windows = ui_kit::Container::host_window_regions(ui.ctx());
            viewport::refresh_layout(self, ui.ctx());
        }
        // Before the dialog: a click on the view's OK or Cancel is for this frame's dialog.
        view_confirm::show(self, ui.ctx());
        dialogs::show(self, ui.ctx());
        issue_report::CadInput::block(self, ui, report_input);
        if !self.universal_panel_host_enabled() {
            sketch_palette::show(self, ui.ctx());
        }
        if !self.universal_panel_host_enabled() {
            self.resolve_fit(ui.ctx());
        }
        params_dialog::show(self, ui.ctx());
        design_properties::show(self, ui.ctx());
        sketch_report::show(self, ui.ctx());
        bom_panel::show(self, ui.ctx());
        material_card_review::show(self, ui.ctx());
        recovery_ui::show(self, ui.ctx());
        mesh_units::show(self, ui.ctx());
        stand_up::show(self, ui.ctx());
        prefs_notice::show(self, ui.ctx());
        context_menu::show(self, ui.ctx());
        mouse_gesture::show(self, ui.ctx());
        delete::show(self, ui.ctx());
        easyprint_ui::show(self, ui.ctx());
        linked_source::show_copies(self, ui.ctx());
        joint_handles::show_warning(self, ui.ctx());
        shortcut_box::show(self, ui.ctx());
        prefs::show(self, ui.ctx());
        toolbar_custom::window(self, ui.ctx());
        // All persistent producers have now registered this pass's actual
        // visible paint. Place independent controls and finish result navigation
        // against those footprints; the render domain stays unchanged.
        if self.universal_panel_host_enabled() {
            self.viewport.host_windows = ui_kit::Container::host_window_regions(ui.ctx());
            if let Some(rect) = self.viewport.rect.filter(|rect| rect.is_positive() && rect.is_finite()) {
                let mut controls = ui.new_child(egui::UiBuilder::new().id_salt("universal_panel_controls").max_rect(rect));
                controls.set_clip_rect(controls.clip_rect().intersect(rect));
                render_workspace::host_result_overlays(self, &mut controls);
                viewport::show_host_controls(self, &mut controls, rect);
            }
            self.resolve_fit(ui.ctx());
        }
        panel_runtime::finish_app_host(self, ui);
    }

    fn show_workspace(&mut self, ui: &mut egui::Ui) {
        if render_workspace::active(self) {
            render_workspace::show(self, ui);
        } else {
            viewport::show(self, ui);
        }
    }

    fn drain_control(&mut self, ctx: &egui::Context) {
        /// Requests run on this thread, so a flood would starve rendering. The rest stay
        /// queued for the next frame.
        const PER_FRAME: usize = 64;

        /// Held requests beyond this are refused rather than kept.
        const MAX_HELD: usize = 256;

        // Held requests (and the agent chat's, which it hands over here) run even when the app
        // has no control channel of its own.
        if self.control_rx.is_none() && self.control_held.is_empty() {
            return;
        }
        let rx = self.control_rx.take();
        for _ in 0..PER_FRAME {
            // A file loading, a save being written, an agent's design change computing, or the
            // agent cursor acting one out: commands that change the design wait their turn (the
            // window, inspection and screenshots still answer, #1989). `engine.script` runs
            // directly, past `SolveApp::run`'s guard, so without the save here it changed the
            // design the save was taken up for (#6003).
            let waits =
                self.file_load.busy() || self.file_picker.is_some() || self.saving.is_some() || self.control_job.is_some() || self.agent.busy();
            // A screenshot waiting for an opened design to be meshed holds what came after it.
            let shot_waits = open_meshing::active(self) && self.control_held.front().is_some_and(|r| r.method == "ui.screenshot");
            // Held requests go first, in order, once nothing makes them wait.
            let held = if waits || shot_waits { None } else { self.control_held.pop_front() };
            let Some(req) = held.or_else(|| rx.as_ref().and_then(|rx| rx.try_recv().ok())) else { break };
            if req.refuse_cancelled_chat() {
                continue;
            }
            if shot_waits {
                if self.control_held.len() < MAX_HELD {
                    self.control_held.push_back(req);
                } else {
                    let _ = req.reply.send(json!({"ok": false, "error": "a file operation is in progress"}));
                }
                continue;
            }
            if (waits && control_job::changes_the_design(&req.method))
                || (self.file_picker_busy() && matches!(req.method.as_str(), "ui.file" | "ui.home"))
                // A screenshot shows the whole design: it waits until an opened one is meshed.
                || (open_meshing::active(self) && req.method == "ui.screenshot")
            {
                if self.control_held.len() < MAX_HELD {
                    self.control_held.push_back(req);
                } else {
                    let _ = req.reply.send(json!({"ok": false, "error": "a file operation is in progress"}));
                }
                continue;
            }
            req.started.store(true, std::sync::atomic::Ordering::Relaxed);
            // Opening or importing a file: answered when the file is in, without freezing the window.
            let Some(req) = file_load::control(self, req) else {
                ctx.request_repaint();
                continue;
            };
            if agent_cursor::intercept(self, &req) {
                ctx.request_repaint();
                continue;
            }
            // A slow design change or export: computed off the window thread (#1989).
            let Some(req) = self.offload_control(ctx, req) else {
                ctx.request_repaint();
                continue;
            };
            self.run_control(ctx, req);
        }
        self.control_rx = rx;
    }

    /// Run a control request here, now, and reply (or queue the screenshot it asks for).
    pub(crate) fn run_control(&mut self, ctx: &egui::Context, req: ControlRequest) {
        if req.refuse_cancelled_chat() {
            return;
        }
        let Some(req) = render_workspace::prepare::control(self, req) else {
            ctx.request_repaint();
            return;
        };
        let reply = req.reply.clone();
        match control::handle(self, ctx, &req) {
            control::Outcome::Done(v) => {
                let _ = reply.send(v);
            }
            // A window that is minimised or covered (another macOS Space) presents no frame:
            // say so at once rather than after the deadline (#1677).
            control::Outcome::Screenshot { .. } if window_hidden(ctx) => {
                let _ = reply.send(json!({"ok": false, "hidden": true, "error": "no frame was presented (window hidden?); use ui.render"}));
            }
            control::Outcome::Screenshot { path } => {
                self.shot_token += 1;
                let token = self.shot_token;
                if let Some(turn) = req.chat_turn {
                    self.shot_chat_turns.insert(token, turn);
                }
                self.queued_shots.push((token, now_ms() + 150.0, 0));
                self.pending_shots.push((token, path, reply, now_ms() + 8000.0));
            }
        }
        ctx.request_repaint();
    }

    fn issue_screenshots(&mut self, ctx: &egui::Context) {
        let now = now_ms();
        // A view that just moved is drawn with fewer AO samples: shoot the full-quality frame
        // that follows (#7165), or after half a second a view that keeps moving as it is.
        let settled = viewport::ao_settled(self, ctx);
        let shot_tx = &self.shot_tx;
        self.queued_shots.retain_mut(|(token, at, frames)| {
            *frames += 1;
            if now >= *at && *frames >= 3 && (settled || now >= *at + 500.0) {
                let (token, tx, ctx2) = (*token, shot_tx.clone(), ctx.clone());
                ctx.request_screenshot(move |image| {
                    let _ = tx.send((token, image));
                    ctx2.request_repaint();
                });
                false
            } else {
                true
            }
        });
        if !self.queued_shots.is_empty() || !self.pending_shots.is_empty() {
            ctx.request_repaint_after(std::time::Duration::from_millis(16));
        }
    }

    fn collect_screenshots(&mut self, ctx: &egui::Context) {
        // A screenshot requested in one tab must never return or save a frame of another.
        let chat_turns = &mut self.shot_chat_turns;
        let queued_shots = &mut self.queued_shots;
        self.pending_shots.retain(|(token, _, reply, _)| {
            if control::chat_turn_cancelled(chat_turns.get(token).map(std::sync::Arc::as_ref)) {
                chat_turns.remove(token);
                queued_shots.retain(|(queued, ..)| queued != token);
                let _ = reply.send(control::cancelled_chat_response());
                false
            } else {
                true
            }
        });
        // Drained every frame: a shot that comes after its request was cancelled or timed out
        // is dropped here instead of waiting in the channel.
        let shots: Vec<_> = self.shot_rx.try_iter().collect();
        if self.pending_shots.is_empty() && !issue_report::pending(self) {
            return;
        }
        for (token, image) in shots {
            issue_report::receive(self, token, image.clone());
            if let Some(i) = self.pending_shots.iter().position(|(t, ..)| *t == token) {
                let (_, path, reply, _) = self.pending_shots.remove(i);
                self.shot_chat_turns.remove(&token);
                let _ = reply.send(control::save_screenshot(&image, path.as_deref()));
            }
        }
        let now = now_ms();
        // Hidden while waiting: no frame is coming.
        let hidden = window_hidden(ctx);
        self.pending_shots.retain(|(token, _, reply, deadline)| {
            if now < *deadline && !hidden {
                return true;
            }
            let _ = reply.send(json!({"ok": false, "error": "no frame was presented (window hidden?); use ui.render"}));
            self.shot_chat_turns.remove(token);
            false
        });
    }
}

/// Drop pointer, wheel and gesture events that carry a non-finite number: egui 0.37 asserts on them.
fn finite_input(raw: &mut egui::RawInput) {
    raw.events.retain(|event| match event {
        egui::Event::PointerMoved(pos) | egui::Event::PointerButton { pos, .. } | egui::Event::MiddleClickPaste { pos, .. } => pos.is_finite(),
        egui::Event::MouseMoved(delta) | egui::Event::MouseWheel { delta, .. } => delta.is_finite(),
        egui::Event::Zoom(amount) | egui::Event::Rotate(amount) => amount.is_finite(),
        egui::Event::Touch { pos, force, .. } => pos.is_finite() && force.is_none_or(f32::is_finite),
        _ => true,
    });
}

/// The window is minimised or fully covered, so it presents no frames (#1677). Unknown counts as
/// shown: the screenshot deadline still ends a wait for a frame that never comes.
fn window_hidden(ctx: &egui::Context) -> bool {
    ctx.input(|i| i.viewport().visible()) == Some(false)
}

/// An edit in place command's result, saying when it waits for the end of the agent's turn.
fn with_queued(mut result: Value, queued: bool) -> Value {
    if queued && let Some(o) = result.as_object_mut() {
        o.insert("queued".into(), Value::Bool(true));
    }
    result
}

/// A command's name as people see it (its label), for the status bar.
pub fn command_label(id: &str) -> &str {
    solidcraft_engine::find_command(id).map_or(id, |c| c.label)
}

/// An engine error with the command's label instead of its id: "Shell: offset must be …".
/// The command label and catalogued engine messages follow the interface language.
pub fn friendly_error(id: &str, e: &str) -> String {
    let label = i18n::tr_label(command_label(id));
    let msg = e.replace(&format!("invalid parameters for `{id}`: "), "").replace(&format!("{id}: "), "").replace(&format!("`{id}`"), label);
    let msg = i18n::tr_engine_error(&msg);
    let msg = i18n::tr_label(&msg);
    if msg.starts_with(label) { msg.to_string() } else { format!("{label}: {msg}") }
}

pub fn now_ms() -> f64 {
    use web_time::{SystemTime, UNIX_EPOCH};
    SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs_f64() * 1000.0).unwrap_or(0.0)
}

#[cfg(test)]
mod picker_test_support;
#[cfg(test)]
mod test_support;

/// Toolbar panels whose commands build features from the model; they finish an open sketch first.
/// Construct, Inspect and Insert keep the sketch open.
const SKETCH_ENDING_PANELS: [&str; 3] = ["CREATE", "MODIFY", "ASSEMBLE"];
const SKETCH_TAB: &str = "SKETCH";

fn ends_sketch(id: &str) -> bool {
    solidcraft_engine::find_command(id).is_some_and(|c| c.tab != SKETCH_TAB && SKETCH_ENDING_PANELS.contains(&c.panel) && c.id != "sketch.create")
}